diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 46fa1de..668f1db 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -1285,14 +1285,20 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
       break;
     case 1:
       // one return parameter
-      if ( vectorParamIndices.find( *nonConstPointerParamIndices.begin() ) == vectorParamIndices.end() )
+      if ( vectorParamIndices.find( nonConstPointerParamIndices[0] ) == vectorParamIndices.end() )
       {
         // the return parameter is not a vector
         if ( ( commandData.returnType == "VkResult" ) &&
-             !isChainableStructure( commandData.params[*nonConstPointerParamIndices.begin()].type.type ) &&
-             !isHandleType( commandData.params[*nonConstPointerParamIndices.begin()].type.type ) )
+             !isChainableStructure( commandData.params[nonConstPointerParamIndices[0]].type.type ) )
         {
-          appendCommandGetValue( str, name, commandData, nonConstPointerParamIndices.front(), definition );
+          if ( isHandleType( commandData.params[nonConstPointerParamIndices[0]].type.type ) )
+          {
+            appendCommandGetHandle( str, name, commandData, nonConstPointerParamIndices[0], definition );
+          }
+          else
+          {
+            appendCommandGetValue( str, name, commandData, nonConstPointerParamIndices[0], definition );
+          }
           appendedFunction = true;
         }
       }
@@ -1704,6 +1710,37 @@ ${commandEnhancedWithAllocators}
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
+void VulkanHppGenerator::appendCommandGetHandle( std::string &       str,
+                                                 std::string const & name,
+                                                 CommandData const & commandData,
+                                                 size_t              nonConstPointerIndex,
+                                                 bool                definition ) const
+{
+  std::string const functionTemplate = R"(
+${enter}${commandStandard}${newlineOnDefinition}
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+${commandEnhanced}${newlineOnDefinition}
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+${commandEnhancedUnique}
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+${leave})";
+
+  std::string enter, leave;
+  std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
+
+  str += replaceWithMap(
+    functionTemplate,
+    std::map<std::string, std::string>(
+      { { "commandEnhanced", constructCommandGetValue( name, commandData, nonConstPointerIndex, definition ) },
+        { "commandEnhancedUnique",
+          constructCommandGetHandleUnique( name, commandData, nonConstPointerIndex, definition ) },
+        { "commandStandard", constructCommandStandard( name, commandData, definition ) },
+        { "enter", enter },
+        { "leave", leave },
+        { "newlineOnDefinition", definition ? "\n" : "" } } ) );
+}
+
 void VulkanHppGenerator::appendCommandGetValue( std::string &       str,
                                                 std::string const & name,
                                                 CommandData const & commandData,
@@ -3368,7 +3405,8 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
 
       // special handling for destroy functions
       if ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
-           ( commandIt->first.substr( 2, 4 ) == "Free" ) )
+           ( commandIt->first.substr( 2, 4 ) == "Free" ) ||
+           ( commandIt->first == "vkReleasePerformanceConfigurationINTEL" ) )
       {
         std::string destroyCommandString;
         // in case there are aliases to this function, filter them out here
@@ -3380,8 +3418,21 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
           commandData.feature.clear();
         }
         appendCommand( destroyCommandString, "    ", commandIt->first, commandData, false );
-        std::string shortenedName = ( commandIt->first.substr( 2, 7 ) == "Destroy" ) ? "destroy" : "free";
-        size_t      pos           = destroyCommandString.find( commandName );
+        std::string shortenedName;
+        if ( commandIt->first.substr( 2, 7 ) == "Destroy" )
+        {
+          shortenedName = "destroy";
+        }
+        else if ( commandIt->first.substr( 2, 4 ) == "Free" )
+        {
+          shortenedName = "free";
+        }
+        else
+        {
+          assert( commandIt->first == "vkReleasePerformanceConfigurationINTEL" );
+          shortenedName = "release";
+        }
+        size_t pos = destroyCommandString.find( commandName );
         while ( pos != std::string::npos )
         {
           destroyCommandString.replace( pos, commandName.length(), shortenedName );
@@ -3562,7 +3613,8 @@ void VulkanHppGenerator::appendHandlesCommandDefinitions( std::string & str ) co
       // special handling for destroy functions
       std::string commandName = determineCommandName( commandIt->first, commandIt->second.params[0].type.type );
       if ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
-           ( commandIt->first.substr( 2, 4 ) == "Free" ) )
+           ( commandIt->first.substr( 2, 4 ) == "Free" ) ||
+           ( commandIt->first == "vkReleasePerformanceConfigurationINTEL" ) )
       {
         std::string destroyCommandString;
         // in case there are aliases to this function, filter them out here
@@ -3577,8 +3629,21 @@ void VulkanHppGenerator::appendHandlesCommandDefinitions( std::string & str ) co
         }
 
         appendCommand( destroyCommandString, "  ", commandIt->first, commandData, true );
-        std::string shortenedName = ( commandIt->first.substr( 2, 7 ) == "Destroy" ) ? "destroy" : "free";
-        size_t      pos           = destroyCommandString.find( commandName );
+        std::string shortenedName;
+        if ( commandIt->first.substr( 2, 7 ) == "Destroy" )
+        {
+          shortenedName = "destroy";
+        }
+        else if ( commandIt->first.substr( 2, 4 ) == "Free" )
+        {
+          shortenedName = "free";
+        }
+        else
+        {
+          assert( commandIt->first == "vkReleasePerformanceConfigurationINTEL" );
+          shortenedName = "release";
+        }
+        size_t pos = destroyCommandString.find( commandName );
         while ( pos != std::string::npos )
         {
           destroyCommandString.replace( pos, commandName.length(), shortenedName );
@@ -3794,12 +3859,10 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
                                                                bool                           definition,
                                                                bool                           withAllocators ) const
 {
-  assert( *skippedParams.begin() == 0 );
-
   size_t defaultStartIndex = determineDefaultStartIndex( params, skippedParams );
 
   std::string argumentList;
-  for ( size_t i = 1; i < params.size(); ++i )
+  for ( size_t i = 0; i < params.size(); ++i )
   {
     if ( skippedParams.find( i ) == skippedParams.end() )
     {
@@ -4422,6 +4485,105 @@ std::string VulkanHppGenerator::constructCommandEnumerateVoid( std::string const
   return str;
 }
 
+std::string VulkanHppGenerator::constructCommandGetHandleUnique( std::string const & name,
+                                                                 CommandData const & commandData,
+                                                                 size_t              nonConstPointerIndex,
+                                                                 bool                definition ) const
+{
+  assert( commandData.successCodes.size() == 1 );
+
+  std::string str;
+
+  std::set<size_t> skippedParams{ nonConstPointerIndex };
+  if ( !commandData.handle.empty() )
+  {
+    assert( commandData.params[0].type.type == commandData.handle );
+    skippedParams.insert( 0 );
+  }
+
+  std::string argumentList   = constructArgumentListEnhanced( commandData.params, skippedParams, definition, false );
+  std::string commandName    = determineCommandName( name, commandData.params[0].type.type );
+  std::string nodiscard      = constructNoDiscardEnhanced( commandData );
+  std::string returnBaseType = commandData.params[nonConstPointerIndex].type.compose();
+  assert( endsWith( returnBaseType, "*" ) );
+  returnBaseType.pop_back();
+
+  if ( definition )
+  {
+    std::string const functionTemplate =
+      R"(  template <typename Dispatch>
+  ${nodiscard}VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<${returnBaseType}, Dispatch>>::type ${className}${classSeparator}${commandName}Unique( ${argumentList} )${const}
+  {
+    ${returnBaseType} ${returnValueName};
+    Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
+    ${ObjectDeleter}<${parentName}, Dispatch> deleter( ${this}${allocator}d );
+    return createResultValue<${returnBaseType}, Dispatch>( result, ${returnValueName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}Unique", deleter );
+  })";
+
+    std::string className = stripPrefix( commandData.handle, "Vk" );
+
+    std::string objectDeleter, allocator;
+    if ( ( name.find( "Acquire" ) != std::string::npos ) || ( name.find( "Get" ) != std::string::npos ) )
+    {
+      assert( ( name == "vkAcquirePerformanceConfigurationINTEL" ) || ( name == "vkGetRandROutputDisplayEXT" ) );
+      objectDeleter = "ObjectRelease";
+    }
+    else if ( name.find( "Allocate" ) != std::string::npos )
+    {
+      objectDeleter = "ObjectFree";
+      allocator     = "allocator, ";
+    }
+    else if ( ( name.find( "Create" ) != std::string::npos ) || ( name.find( "Register" ) != std::string::npos ) )
+    {
+      assert( ( name.find( "Create" ) != std::string::npos ) || ( name == "vkRegisterDeviceEventEXT" ) ||
+              ( name == "vkRegisterDisplayEventEXT" ) );
+      objectDeleter = "ObjectDestroy";
+      allocator     = "allocator, ";
+    }
+    else
+    {
+      assert( false );
+    }
+    std::string parentName =
+      ( className.empty() || ( commandData.params[nonConstPointerIndex].type.type == "VkDevice" ) ) ? "NoParent"
+                                                                                                    : className;
+
+    str = replaceWithMap(
+      functionTemplate,
+      std::map<std::string, std::string>(
+        { { "allocator", allocator },
+          { "argumentList", argumentList },
+          { "callArguments",
+            constructCallArgumentsGetValue( commandData.handle, commandData.params, nonConstPointerIndex ) },
+          { "className", className },
+          { "classSeparator", className.empty() ? "" : "::" },
+          { "commandName", commandName },
+          { "const", commandData.handle.empty() ? "" : " const" },
+          { "nodiscard", nodiscard },
+          { "ObjectDeleter", objectDeleter },
+          { "parentName", parentName },
+          { "returnBaseType", returnBaseType },
+          { "returnValueName", startLowerCase( stripPrefix( commandData.params[nonConstPointerIndex].name, "p" ) ) },
+          { "this", ( parentName == "NoParent" ) ? "" : "*this, " },
+          { "vkCommand", name } } ) );
+  }
+  else
+  {
+    std::string const functionTemplate =
+      R"(  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  ${nodiscard}VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<${returnBaseType}, Dispatch>>::type ${commandName}Unique( ${argumentList} )${const};)";
+
+    str = replaceWithMap( functionTemplate,
+                          std::map<std::string, std::string>( { { "argumentList", argumentList },
+                                                                { "commandName", commandName },
+                                                                { "const", commandData.handle.empty() ? "" : " const" },
+                                                                { "nodiscard", nodiscard },
+                                                                { "returnBaseType", returnBaseType } } ) );
+  }
+
+  return str;
+}
+
 std::string VulkanHppGenerator::constructCommandGetValue( std::string const & name,
                                                           CommandData const & commandData,
                                                           size_t              nonConstPointerIndex,
@@ -9858,6 +10020,37 @@ int main( int argc, char ** argv )
   };
 )";
 
+  static const std::string classObjectRelease = R"(
+  template <typename OwnerType, typename Dispatch>
+  class ObjectRelease
+  {
+  public:
+    ObjectRelease() = default;
+
+    ObjectRelease( 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.release( t, *m_dispatch );
+    }
+
+  private:
+    OwnerType        m_owner    = {};
+    Dispatch const * m_dispatch = nullptr;
+  };
+)";
+
   static const std::string classOptional = R"(
   template <typename RefType>
   class Optional
@@ -10836,7 +11029,7 @@ namespace std
            classFlags + classOptional + classStructureChain + classUniqueHandle;
     generator.appendDispatchLoaderStatic( str );
     generator.appendDispatchLoaderDefault( str );
-    str += classObjectDestroy + classObjectFree + classPoolFree + "\n";
+    str += classObjectDestroy + classObjectFree + classObjectRelease + classPoolFree + "\n";
     generator.appendBaseTypes( str );
     str += typeTraits;
     generator.appendEnums( str );
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 0e6e13d..73fd166 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -326,6 +326,11 @@ private:
                                           CommandData const &               commandData,
                                           std::pair<size_t, size_t> const & vectorParamIndex,
                                           bool                              definition ) const;
+  void        appendCommandGetHandle( std::string &       str,
+                                      std::string const & name,
+                                      CommandData const & commandData,
+                                      size_t              nonConstPointerIndex,
+                                      bool                definition ) const;
   void        appendCommandGetValue( std::string &       str,
                                      std::string const & name,
                                      CommandData const & commandData,
@@ -463,23 +468,23 @@ private:
                                                            std::string const & strippedParameterName,
                                                            bool                withDefaults,
                                                            bool                withAllocator ) const;
-  void appendFunctionHeaderArgumentEnhancedVector( std::string &       str,
-                                                   ParamData const &   param,
-                                                   std::string const & strippedParameterName,
-                                                   bool                hasSizeParam,
-                                                   bool                isTemplateParam,
-                                                   bool                singular,
-                                                   bool                withDefaults,
-                                                   bool                withAllocator ) const;
-  void appendFunctionHeaderArguments( std::string &                    str,
-                                      CommandData const &              commandData,
-                                      size_t                           returnParamIndex,
-                                      size_t                           templateParamIndex,
-                                      std::map<size_t, size_t> const & vectorParamIndices,
-                                      bool                             enhanced,
-                                      bool                             singular,
-                                      bool                             withDefaults,
-                                      bool                             withAllocator ) const;
+  void        appendFunctionHeaderArgumentEnhancedVector( std::string &       str,
+                                                          ParamData const &   param,
+                                                          std::string const & strippedParameterName,
+                                                          bool                hasSizeParam,
+                                                          bool                isTemplateParam,
+                                                          bool                singular,
+                                                          bool                withDefaults,
+                                                          bool                withAllocator ) const;
+  void        appendFunctionHeaderArguments( std::string &                    str,
+                                             CommandData const &              commandData,
+                                             size_t                           returnParamIndex,
+                                             size_t                           templateParamIndex,
+                                             std::map<size_t, size_t> const & vectorParamIndices,
+                                             bool                             enhanced,
+                                             bool                             singular,
+                                             bool                             withDefaults,
+                                             bool                             withAllocator ) const;
   bool appendFunctionHeaderArgumentStandard( std::string & str, ParamData const & param, bool argEncountered ) const;
   void appendFunctionHeaderReturnType( std::string &                    str,
                                        CommandData const &              commandData,
@@ -569,6 +574,10 @@ private:
                                              std::pair<size_t, size_t> const & vectorParamIndex,
                                              bool                              definition,
                                              bool                              withAllocators ) const;
+  std::string constructCommandGetHandleUnique( std::string const & name,
+                                               CommandData const & commandData,
+                                               size_t              nonConstPointerIndex,
+                                               bool                definition ) const;
   std::string constructCommandGetValue( std::string const & name,
                                         CommandData const & commandData,
                                         size_t              nonConstPointerIndex,
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 3a1fdbc..6191d78 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -4999,6 +4999,35 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const *                    m_dispatch            = nullptr;
   };
 
+  template <typename OwnerType, typename Dispatch>
+  class ObjectRelease
+  {
+  public:
+    ObjectRelease() = default;
+
+    ObjectRelease( 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.release( t, *m_dispatch );
+    }
+
+  private:
+    OwnerType        m_owner    = {};
+    Dispatch const * m_dispatch = nullptr;
+  };
+
   template <typename OwnerType, typename PoolType, typename Dispatch>
   class PoolFree
   {
@@ -52046,7 +52075,14 @@ namespace VULKAN_HPP_NAMESPACE
       typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
       acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  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::PerformanceConfigurationINTEL, Dispatch>>::type
+      acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
+                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
@@ -52153,7 +52189,8 @@ namespace VULKAN_HPP_NAMESPACE
                       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 typename ResultValueType<UniqueHandle<DeviceMemory, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
       allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo,
                             Optional<const AllocationCallbacks> allocator
                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52353,8 +52390,8 @@ namespace VULKAN_HPP_NAMESPACE
                                       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
-      typename ResultValueType<UniqueHandle<AccelerationStructureKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
       createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
                                             Optional<const AllocationCallbacks> allocator
                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52364,11 +52401,11 @@ namespace VULKAN_HPP_NAMESPACE
 #endif     /*VK_ENABLE_BETA_EXTENSIONS*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
-                                          VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
+    VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
+      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>
     typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV(
@@ -52377,10 +52414,12 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<AccelerationStructureNV, Dispatch>>::type createAccelerationStructureNVUnique(
-      const AccelerationStructureCreateInfoNV &     createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
+      createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
+                                           Optional<const AllocationCallbacks> allocator
+                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -52398,7 +52437,8 @@ namespace VULKAN_HPP_NAMESPACE
                     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 typename ResultValueType<UniqueHandle<Buffer, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
       createBufferUnique( const BufferCreateInfo &                      createInfo,
                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -52419,7 +52459,8 @@ namespace VULKAN_HPP_NAMESPACE
                         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 typename ResultValueType<UniqueHandle<BufferView, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
       createBufferViewUnique( const BufferViewCreateInfo & createInfo,
                               Optional<const AllocationCallbacks> allocator
                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52441,7 +52482,8 @@ namespace VULKAN_HPP_NAMESPACE
                          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 typename ResultValueType<UniqueHandle<CommandPool, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
       createCommandPoolUnique( const CommandPoolCreateInfo & createInfo,
                                Optional<const AllocationCallbacks> allocator
                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52512,10 +52554,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                       VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
+    VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
+      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>
     typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR(
@@ -52523,9 +52565,10 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<DeferredOperationKHR, Dispatch>>::type createDeferredOperationKHRUnique(
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
+      createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator
+                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif     /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -52545,7 +52588,8 @@ namespace VULKAN_HPP_NAMESPACE
                             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 typename ResultValueType<UniqueHandle<DescriptorPool, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
       createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo,
                                   Optional<const AllocationCallbacks> allocator
                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52568,7 +52612,8 @@ namespace VULKAN_HPP_NAMESPACE
                                  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 typename ResultValueType<UniqueHandle<DescriptorSetLayout, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
       createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
                                        Optional<const AllocationCallbacks> allocator
                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52592,8 +52637,8 @@ namespace VULKAN_HPP_NAMESPACE
                                       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
-      typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
       createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
                                             Optional<const AllocationCallbacks> allocator
                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52617,8 +52662,8 @@ namespace VULKAN_HPP_NAMESPACE
                                          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
-      typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
       createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
                                                Optional<const AllocationCallbacks> allocator
                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52640,7 +52685,8 @@ namespace VULKAN_HPP_NAMESPACE
                    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 typename ResultValueType<UniqueHandle<Event, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
       createEventUnique( const EventCreateInfo &                       createInfo,
                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -52661,7 +52707,8 @@ namespace VULKAN_HPP_NAMESPACE
                    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 typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
       createFenceUnique( const FenceCreateInfo &                       createInfo,
                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -52682,7 +52729,8 @@ namespace VULKAN_HPP_NAMESPACE
                          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 typename ResultValueType<UniqueHandle<Framebuffer, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
       createFramebufferUnique( const FramebufferCreateInfo & createInfo,
                                Optional<const AllocationCallbacks> allocator
                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52765,7 +52813,8 @@ namespace VULKAN_HPP_NAMESPACE
                    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 typename ResultValueType<UniqueHandle<Image, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
       createImageUnique( const ImageCreateInfo &                       createInfo,
                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -52786,7 +52835,8 @@ namespace VULKAN_HPP_NAMESPACE
                        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 typename ResultValueType<UniqueHandle<ImageView, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
       createImageViewUnique( const ImageViewCreateInfo & createInfo,
                              Optional<const AllocationCallbacks> allocator
                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52810,8 +52860,8 @@ namespace VULKAN_HPP_NAMESPACE
                                       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
-      typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNV, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
       createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo,
                                             Optional<const AllocationCallbacks> allocator
                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52833,7 +52883,8 @@ namespace VULKAN_HPP_NAMESPACE
                            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 typename ResultValueType<UniqueHandle<PipelineCache, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
       createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo,
                                  Optional<const AllocationCallbacks> allocator
                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52856,7 +52907,8 @@ namespace VULKAN_HPP_NAMESPACE
                             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 typename ResultValueType<UniqueHandle<PipelineLayout, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
       createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo,
                                   Optional<const AllocationCallbacks> allocator
                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -52865,7 +52917,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result
+    VULKAN_HPP_NODISCARD Result
       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT * pCreateInfo,
                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
                                 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT *                 pPrivateDataSlot,
@@ -52878,10 +52930,11 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<PrivateDataSlotEXT, Dispatch>>::type createPrivateDataSlotEXTUnique(
-      const PrivateDataSlotCreateInfoEXT &          createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>>::type
+      createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfoEXT & createInfo,
+                                      Optional<const AllocationCallbacks> allocator
+                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -52899,7 +52952,8 @@ namespace VULKAN_HPP_NAMESPACE
                        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 typename ResultValueType<UniqueHandle<QueryPool, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
       createQueryPoolUnique( const QueryPoolCreateInfo & createInfo,
                              Optional<const AllocationCallbacks> allocator
                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53045,7 +53099,8 @@ namespace VULKAN_HPP_NAMESPACE
                         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 typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
       createRenderPassUnique( const RenderPassCreateInfo & createInfo,
                               Optional<const AllocationCallbacks> allocator
                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53067,7 +53122,8 @@ namespace VULKAN_HPP_NAMESPACE
                          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 typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
       createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo,
                                Optional<const AllocationCallbacks> allocator
                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53090,7 +53146,8 @@ namespace VULKAN_HPP_NAMESPACE
                             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 typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
       createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo,
                                   Optional<const AllocationCallbacks> allocator
                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53112,7 +53169,8 @@ namespace VULKAN_HPP_NAMESPACE
                      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 typename ResultValueType<UniqueHandle<Sampler, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
       createSamplerUnique( const SamplerCreateInfo &                     createInfo,
                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -53134,8 +53192,8 @@ namespace VULKAN_HPP_NAMESPACE
                                     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
-      typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
       createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
                                           Optional<const AllocationCallbacks> allocator
                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53158,8 +53216,8 @@ namespace VULKAN_HPP_NAMESPACE
                                        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
-      typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
       createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
                                              Optional<const AllocationCallbacks> allocator
                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53181,7 +53239,8 @@ namespace VULKAN_HPP_NAMESPACE
                        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 typename ResultValueType<UniqueHandle<Semaphore, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
       createSemaphoreUnique( const SemaphoreCreateInfo & createInfo,
                              Optional<const AllocationCallbacks> allocator
                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53203,7 +53262,8 @@ namespace VULKAN_HPP_NAMESPACE
                           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 typename ResultValueType<UniqueHandle<ShaderModule, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
       createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo,
                                 Optional<const AllocationCallbacks> allocator
                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53283,7 +53343,8 @@ namespace VULKAN_HPP_NAMESPACE
                           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 typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
       createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
                                 Optional<const AllocationCallbacks> allocator
                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -53292,7 +53353,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result
+    VULKAN_HPP_NODISCARD Result
       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
                                 VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
@@ -53305,10 +53366,11 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<ValidationCacheEXT, Dispatch>>::type createValidationCacheEXTUnique(
-      const ValidationCacheCreateInfoEXT &          createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
+      createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
+                                      Optional<const AllocationCallbacks> allocator
+                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -55458,10 +55520,11 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                             VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    VULKAN_HPP_NODISCARD Result
+      registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
+                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                        VULKAN_HPP_NAMESPACE::Fence *                     pFence,
+                        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>
     typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
@@ -55470,15 +55533,16 @@ namespace VULKAN_HPP_NAMESPACE
                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type registerEventEXTUnique(
-      const DeviceEventInfoEXT &                    deviceEventInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+      registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo,
+                              Optional<const AllocationCallbacks> allocator
+                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result
+    VULKAN_HPP_NODISCARD Result
       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -55493,11 +55557,12 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type registerDisplayEventEXTUnique(
-      VULKAN_HPP_NAMESPACE::DisplayKHR              display,
-      const DisplayEventInfoEXT &                   displayEventInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+      registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                     const DisplayEventInfoEXT &      displayEventInfo,
+                                     Optional<const AllocationCallbacks> allocator
+                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -55527,6 +55592,18 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+               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
+      release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void
       releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -60397,7 +60474,8 @@ namespace VULKAN_HPP_NAMESPACE
                     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 typename ResultValueType<UniqueHandle<Device, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
       createDeviceUnique( const DeviceCreateInfo &                      createInfo,
                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -60419,7 +60497,17 @@ namespace VULKAN_HPP_NAMESPACE
                             Optional<const AllocationCallbacks> allocator
                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  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::DisplayModeKHR, Dispatch>>::type
+      createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                  const DisplayModeCreateInfoKHR & createInfo,
+                                  Optional<const AllocationCallbacks> allocator
+                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(
@@ -61498,7 +61586,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result
+    VULKAN_HPP_NODISCARD Result
       getRandROutputDisplayEXT( Display *                          dpy,
                                 RROutput                           rrOutput,
                                 VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
@@ -61507,8 +61595,15 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT(
       Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
+      getRandROutputDisplayEXTUnique( Display &          dpy,
+                                      RROutput           rrOutput,
+                                      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_XLIB_XRANDR_EXT*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -88743,7 +88838,8 @@ namespace VULKAN_HPP_NAMESPACE
                                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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
                                      Optional<const AllocationCallbacks> allocator
                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88753,11 +88849,11 @@ namespace VULKAN_HPP_NAMESPACE
 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
-                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-                                         VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
+    VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(
+      const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+      VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
+      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>
     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT(
@@ -88766,19 +88862,21 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<DebugReportCallbackEXT, Dispatch>>::type createDebugReportCallbackEXTUnique(
-      const DebugReportCallbackCreateInfoEXT &      createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
+      createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
+                                          Optional<const AllocationCallbacks> allocator
+                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
-                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-                                         VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
+    VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(
+      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
+      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>
     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT(
@@ -88787,10 +88885,12 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT, Dispatch>>::type createDebugUtilsMessengerEXTUnique(
-      const DebugUtilsMessengerCreateInfoEXT &      createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
+      createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
+                                          Optional<const AllocationCallbacks> allocator
+                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -88810,7 +88910,8 @@ namespace VULKAN_HPP_NAMESPACE
                                 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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
                                       Optional<const AllocationCallbacks> allocator
                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88834,7 +88935,8 @@ namespace VULKAN_HPP_NAMESPACE
                                     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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
                                           Optional<const AllocationCallbacks> allocator
                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88857,7 +88959,8 @@ namespace VULKAN_HPP_NAMESPACE
                                 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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
                                       Optional<const AllocationCallbacks> allocator
                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88880,7 +88983,8 @@ namespace VULKAN_HPP_NAMESPACE
                            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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo,
                                  Optional<const AllocationCallbacks> allocator
                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88905,7 +89009,8 @@ namespace VULKAN_HPP_NAMESPACE
                                      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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
                                            Optional<const AllocationCallbacks> allocator
                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88930,7 +89035,8 @@ namespace VULKAN_HPP_NAMESPACE
                              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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo,
                                    Optional<const AllocationCallbacks> allocator
                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88955,7 +89061,8 @@ namespace VULKAN_HPP_NAMESPACE
                              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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo,
                                    Optional<const AllocationCallbacks> allocator
                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -88980,7 +89087,8 @@ namespace VULKAN_HPP_NAMESPACE
                                         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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
                                               Optional<const AllocationCallbacks> allocator
                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -89004,7 +89112,8 @@ namespace VULKAN_HPP_NAMESPACE
                          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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo,
                                Optional<const AllocationCallbacks> allocator
                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -89029,7 +89138,8 @@ namespace VULKAN_HPP_NAMESPACE
                                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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
                                      Optional<const AllocationCallbacks> allocator
                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -89054,7 +89164,8 @@ namespace VULKAN_HPP_NAMESPACE
                              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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo,
                                    Optional<const AllocationCallbacks> allocator
                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -89078,7 +89189,8 @@ namespace VULKAN_HPP_NAMESPACE
                            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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo,
                                  Optional<const AllocationCallbacks> allocator
                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -89103,7 +89215,8 @@ namespace VULKAN_HPP_NAMESPACE
                             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 typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
       createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo,
                                   Optional<const AllocationCallbacks> allocator
                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -89369,7 +89482,8 @@ namespace VULKAN_HPP_NAMESPACE
                     Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<Instance, Dispatch>>::type
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
     createInstanceUnique( const InstanceCreateInfo &                    createInfo,
                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
@@ -89438,6 +89552,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                     reinterpret_cast<VkInstance *>( pInstance ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -89447,28 +89562,30 @@ namespace VULKAN_HPP_NAMESPACE
                     Dispatch const &                    d )
   {
     VULKAN_HPP_NAMESPACE::Instance instance;
-    Result                         result = static_cast<Result>( d.vkCreateInstance(
-      reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkInstance *>( &instance ) ) );
+    Result                         result = static_cast<Result>(
+      d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                          reinterpret_cast<VkInstance *>( &instance ) ) );
     return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING "::createInstance" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Instance, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
     createInstanceUnique( const InstanceCreateInfo &          createInfo,
                           Optional<const AllocationCallbacks> allocator,
                           Dispatch const &                    d )
   {
     VULKAN_HPP_NAMESPACE::Instance instance;
-    Result                         result = static_cast<Result>( d.vkCreateInstance(
-      reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkInstance *>( &instance ) ) );
-
+    Result                         result = static_cast<Result>(
+      d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                          reinterpret_cast<VkInstance *>( &instance ) ) );
     ObjectDestroy<NoParent, Dispatch> deleter( allocator, d );
-    return createResultValue<Instance, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Instance, Dispatch>(
       result, instance, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -92276,6 +92393,7 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( pAcquireInfo ),
       reinterpret_cast<VkPerformanceConfigurationINTEL *>( pConfiguration ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -92291,7 +92409,28 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, configuration, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" );
   }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
+    Device::acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
+                                                        Dispatch const &                                 d ) const
+  {
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
+    Result                          result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL(
+      m_device,
+      reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
+      reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
+    ObjectRelease<Device, Dispatch> deleter( *this, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>(
+      result,
+      configuration,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique",
+      deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR(
@@ -92522,6 +92661,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                     reinterpret_cast<VkDeviceMemory *>( pMemory ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -92531,30 +92671,32 @@ namespace VULKAN_HPP_NAMESPACE
                             Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::DeviceMemory memory;
-    Result                             result = static_cast<Result>( d.vkAllocateMemory(
-      m_device,
-      reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDeviceMemory *>( &memory ) ) );
+    Result                             result = static_cast<Result>(
+      d.vkAllocateMemory( m_device,
+                          reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                          reinterpret_cast<VkDeviceMemory *>( &memory ) ) );
     return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<DeviceMemory, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
     Device::allocateMemoryUnique( const MemoryAllocateInfo &          allocateInfo,
                                   Optional<const AllocationCallbacks> allocator,
                                   Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::DeviceMemory memory;
-    Result                             result = static_cast<Result>( d.vkAllocateMemory(
-      m_device,
-      reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDeviceMemory *>( &memory ) ) );
-
+    Result                             result = static_cast<Result>(
+      d.vkAllocateMemory( m_device,
+                          reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                          reinterpret_cast<VkDeviceMemory *>( &memory ) ) );
     ObjectFree<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DeviceMemory, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>(
       result, memory, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -92901,6 +93043,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                           reinterpret_cast<VkAccelerationStructureKHR *>( pAccelerationStructure ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -92913,15 +93056,17 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateAccelerationStructureKHR(
       m_device,
       reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
     return createResultValue(
       result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<AccelerationStructureKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
     Device::createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
                                                   Optional<const AllocationCallbacks>        allocator,
                                                   Dispatch const &                           d ) const
@@ -92930,22 +93075,22 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateAccelerationStructureKHR(
       m_device,
       reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
-
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<AccelerationStructureKHR, Dispatch>( result,
-                                                                  accelerationStructure,
-                                                                  VULKAN_HPP_NAMESPACE_STRING
-                                                                  "::Device::createAccelerationStructureKHRUnique",
-                                                                  deleter );
+    ObjectDestroy<Device, Dispatch>                deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>(
+      result,
+      accelerationStructure,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique",
+      deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif     /*VK_ENABLE_BETA_EXTENSIONS*/
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
                                            VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure,
@@ -92957,6 +93102,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                          reinterpret_cast<VkAccelerationStructureNV *>( pAccelerationStructure ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
@@ -92968,14 +93114,17 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                        result = static_cast<Result>( d.vkCreateAccelerationStructureNV(
       m_device,
       reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
     return createResultValue(
       result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNV, Dispatch>>::type
+  VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
     Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
                                                  Optional<const AllocationCallbacks>       allocator,
                                                  Dispatch const &                          d ) const
@@ -92984,15 +93133,15 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                        result = static_cast<Result>( d.vkCreateAccelerationStructureNV(
       m_device,
       reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
-
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<AccelerationStructureNV, Dispatch>( result,
-                                                                 accelerationStructure,
-                                                                 VULKAN_HPP_NAMESPACE_STRING
-                                                                 "::Device::createAccelerationStructureNVUnique",
-                                                                 deleter );
+    ObjectDestroy<Device, Dispatch>               deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>(
+      result,
+      accelerationStructure,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique",
+      deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -93009,6 +93158,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                   reinterpret_cast<VkBuffer *>( pBuffer ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
@@ -93017,30 +93167,32 @@ namespace VULKAN_HPP_NAMESPACE
                           Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Buffer buffer;
-    Result                       result = static_cast<Result>( d.vkCreateBuffer(
-      m_device,
-      reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkBuffer *>( &buffer ) ) );
+    Result                       result = static_cast<Result>(
+      d.vkCreateBuffer( m_device,
+                        reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                        reinterpret_cast<VkBuffer *>( &buffer ) ) );
     return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Buffer, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
     Device::createBufferUnique( const BufferCreateInfo &            createInfo,
                                 Optional<const AllocationCallbacks> allocator,
                                 Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Buffer buffer;
-    Result                       result = static_cast<Result>( d.vkCreateBuffer(
-      m_device,
-      reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkBuffer *>( &buffer ) ) );
-
+    Result                       result = static_cast<Result>(
+      d.vkCreateBuffer( m_device,
+                        reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                        reinterpret_cast<VkBuffer *>( &buffer ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Buffer, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>(
       result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93058,6 +93210,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                       reinterpret_cast<VkBufferView *>( pView ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93067,30 +93220,32 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::BufferView view;
-    Result                           result = static_cast<Result>( d.vkCreateBufferView(
-      m_device,
-      reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkBufferView *>( &view ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateBufferView( m_device,
+                            reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                            reinterpret_cast<VkBufferView *>( &view ) ) );
     return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<BufferView, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
     Device::createBufferViewUnique( const BufferViewCreateInfo &        createInfo,
                                     Optional<const AllocationCallbacks> allocator,
                                     Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::BufferView view;
-    Result                           result = static_cast<Result>( d.vkCreateBufferView(
-      m_device,
-      reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkBufferView *>( &view ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateBufferView( m_device,
+                            reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                            reinterpret_cast<VkBufferView *>( &view ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<BufferView, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>(
       result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93108,6 +93263,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                        reinterpret_cast<VkCommandPool *>( pCommandPool ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93117,30 +93273,32 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::CommandPool commandPool;
-    Result                            result = static_cast<Result>( d.vkCreateCommandPool(
-      m_device,
-      reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
+    Result                            result = static_cast<Result>(
+      d.vkCreateCommandPool( m_device,
+                             reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
     return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<CommandPool, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
     Device::createCommandPoolUnique( const CommandPoolCreateInfo &       createInfo,
                                      Optional<const AllocationCallbacks> allocator,
                                      Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::CommandPool commandPool;
-    Result                            result = static_cast<Result>( d.vkCreateCommandPool(
-      m_device,
-      reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
-
+    Result                            result = static_cast<Result>(
+      d.vkCreateCommandPool( m_device,
+                             reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<CommandPool, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>(
       result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93330,7 +93488,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
                                         VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
                                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
@@ -93340,32 +93498,35 @@ namespace VULKAN_HPP_NAMESPACE
                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                       reinterpret_cast<VkDeferredOperationKHR *>( pDeferredOperation ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
     Device::createDeferredOperationKHR( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
-    Result                                     result = static_cast<Result>( d.vkCreateDeferredOperationKHR(
-      m_device,
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
+    Result                                     result = static_cast<Result>(
+      d.vkCreateDeferredOperationKHR( m_device,
+                                      reinterpret_cast<const VkAllocationCallbacks *>(
+                                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
     return createResultValue(
       result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DeferredOperationKHR, Dispatch>>::type
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
     Device::createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
-    Result                                     result = static_cast<Result>( d.vkCreateDeferredOperationKHR(
-      m_device,
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
-
+    Result                                     result = static_cast<Result>(
+      d.vkCreateDeferredOperationKHR( m_device,
+                                      reinterpret_cast<const VkAllocationCallbacks *>(
+                                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DeferredOperationKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>(
       result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93385,6 +93546,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                 reinterpret_cast<VkDescriptorPool *>( pDescriptorPool ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93394,30 +93556,32 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool;
-    Result                               result = static_cast<Result>( d.vkCreateDescriptorPool(
-      m_device,
-      reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) );
+    Result                               result = static_cast<Result>(
+      d.vkCreateDescriptorPool( m_device,
+                                reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) );
     return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<DescriptorPool, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
     Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo &    createInfo,
                                         Optional<const AllocationCallbacks> allocator,
                                         Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool;
-    Result                               result = static_cast<Result>( d.vkCreateDescriptorPool(
-      m_device,
-      reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) );
-
+    Result                               result = static_cast<Result>(
+      d.vkCreateDescriptorPool( m_device,
+                                reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DescriptorPool, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>(
       result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93436,6 +93600,7 @@ namespace VULKAN_HPP_NAMESPACE
                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                      reinterpret_cast<VkDescriptorSetLayout *>( pSetLayout ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93445,30 +93610,32 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                      d ) const
   {
     VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
-    Result                                    result = static_cast<Result>( d.vkCreateDescriptorSetLayout(
-      m_device,
-      reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
+    Result                                    result = static_cast<Result>(
+      d.vkCreateDescriptorSetLayout( m_device,
+                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
     return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<DescriptorSetLayout, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
     Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
                                              Optional<const AllocationCallbacks>   allocator,
                                              Dispatch const &                      d ) const
   {
     VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
-    Result                                    result = static_cast<Result>( d.vkCreateDescriptorSetLayout(
-      m_device,
-      reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
-
+    Result                                    result = static_cast<Result>(
+      d.vkCreateDescriptorSetLayout( m_device,
+                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DescriptorSetLayout, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>(
       result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93487,6 +93654,7 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
       reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93499,15 +93667,17 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate(
       m_device,
       reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
     return createResultValue(
       result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
     Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
                                                   Optional<const AllocationCallbacks>        allocator,
                                                   Dispatch const &                           d ) const
@@ -93516,15 +93686,15 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate(
       m_device,
       reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
-
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DescriptorUpdateTemplate, Dispatch>( result,
-                                                                  descriptorUpdateTemplate,
-                                                                  VULKAN_HPP_NAMESPACE_STRING
-                                                                  "::Device::createDescriptorUpdateTemplateUnique",
-                                                                  deleter );
+    ObjectDestroy<Device, Dispatch>                deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>(
+      result,
+      descriptorUpdateTemplate,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique",
+      deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -93542,6 +93712,7 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
       reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93554,15 +93725,17 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR(
       m_device,
       reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
     return createResultValue(
       result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
     Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
                                                      Optional<const AllocationCallbacks>        allocator,
                                                      Dispatch const &                           d ) const
@@ -93571,15 +93744,15 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR(
       m_device,
       reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
-
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DescriptorUpdateTemplate, Dispatch>( result,
-                                                                  descriptorUpdateTemplate,
-                                                                  VULKAN_HPP_NAMESPACE_STRING
-                                                                  "::Device::createDescriptorUpdateTemplateKHRUnique",
-                                                                  deleter );
+    ObjectDestroy<Device, Dispatch>                deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>(
+      result,
+      descriptorUpdateTemplate,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHRUnique",
+      deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -93596,6 +93769,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                  reinterpret_cast<VkEvent *>( pEvent ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
@@ -93604,30 +93778,32 @@ namespace VULKAN_HPP_NAMESPACE
                          Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Event event;
-    Result                      result = static_cast<Result>( d.vkCreateEvent(
-      m_device,
-      reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkEvent *>( &event ) ) );
+    Result                      result = static_cast<Result>(
+      d.vkCreateEvent( m_device,
+                       reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkEvent *>( &event ) ) );
     return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Event, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
     Device::createEventUnique( const EventCreateInfo &             createInfo,
                                Optional<const AllocationCallbacks> allocator,
                                Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Event event;
-    Result                      result = static_cast<Result>( d.vkCreateEvent(
-      m_device,
-      reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkEvent *>( &event ) ) );
-
+    Result                      result = static_cast<Result>(
+      d.vkCreateEvent( m_device,
+                       reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkEvent *>( &event ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Event, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Event, Dispatch>(
       result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93645,6 +93821,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                  reinterpret_cast<VkFence *>( pFence ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
@@ -93653,30 +93830,32 @@ namespace VULKAN_HPP_NAMESPACE
                          Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>( d.vkCreateFence(
-      m_device,
-      reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFence *>( &fence ) ) );
+    Result                      result = static_cast<Result>(
+      d.vkCreateFence( m_device,
+                       reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkFence *>( &fence ) ) );
     return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
     Device::createFenceUnique( const FenceCreateInfo &             createInfo,
                                Optional<const AllocationCallbacks> allocator,
                                Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>( d.vkCreateFence(
-      m_device,
-      reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFence *>( &fence ) ) );
-
+    Result                      result = static_cast<Result>(
+      d.vkCreateFence( m_device,
+                       reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkFence *>( &fence ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Fence, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
       result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93694,6 +93873,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                        reinterpret_cast<VkFramebuffer *>( pFramebuffer ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93703,30 +93883,32 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
-    Result                            result = static_cast<Result>( d.vkCreateFramebuffer(
-      m_device,
-      reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
+    Result                            result = static_cast<Result>(
+      d.vkCreateFramebuffer( m_device,
+                             reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
     return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Framebuffer, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
     Device::createFramebufferUnique( const FramebufferCreateInfo &       createInfo,
                                      Optional<const AllocationCallbacks> allocator,
                                      Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
-    Result                            result = static_cast<Result>( d.vkCreateFramebuffer(
-      m_device,
-      reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
-
+    Result                            result = static_cast<Result>(
+      d.vkCreateFramebuffer( m_device,
+                             reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Framebuffer, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>(
       result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93926,6 +94108,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                  reinterpret_cast<VkImage *>( pImage ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
@@ -93934,30 +94117,32 @@ namespace VULKAN_HPP_NAMESPACE
                          Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Image image;
-    Result                      result = static_cast<Result>( d.vkCreateImage(
-      m_device,
-      reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkImage *>( &image ) ) );
+    Result                      result = static_cast<Result>(
+      d.vkCreateImage( m_device,
+                       reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkImage *>( &image ) ) );
     return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Image, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
     Device::createImageUnique( const ImageCreateInfo &             createInfo,
                                Optional<const AllocationCallbacks> allocator,
                                Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Image image;
-    Result                      result = static_cast<Result>( d.vkCreateImage(
-      m_device,
-      reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkImage *>( &image ) ) );
-
+    Result                      result = static_cast<Result>(
+      d.vkCreateImage( m_device,
+                       reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkImage *>( &image ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Image, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Image, Dispatch>(
       result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -93975,6 +94160,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                      reinterpret_cast<VkImageView *>( pView ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -93984,30 +94170,32 @@ namespace VULKAN_HPP_NAMESPACE
                              Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::ImageView view;
-    Result                          result = static_cast<Result>( d.vkCreateImageView(
-      m_device,
-      reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkImageView *>( &view ) ) );
+    Result                          result = static_cast<Result>(
+      d.vkCreateImageView( m_device,
+                           reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkImageView *>( &view ) ) );
     return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<ImageView, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
     Device::createImageViewUnique( const ImageViewCreateInfo &         createInfo,
                                    Optional<const AllocationCallbacks> allocator,
                                    Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::ImageView view;
-    Result                          result = static_cast<Result>( d.vkCreateImageView(
-      m_device,
-      reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkImageView *>( &view ) ) );
-
+    Result                          result = static_cast<Result>(
+      d.vkCreateImageView( m_device,
+                           reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkImageView *>( &view ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<ImageView, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>(
       result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94026,6 +94214,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                           reinterpret_cast<VkIndirectCommandsLayoutNV *>( pIndirectCommandsLayout ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94038,15 +94227,17 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV(
       m_device,
       reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) );
     return createResultValue(
       result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNV, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
     Device::createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo,
                                                   Optional<const AllocationCallbacks>        allocator,
                                                   Dispatch const &                           d ) const
@@ -94055,15 +94246,15 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                         result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV(
       m_device,
       reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) );
-
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<IndirectCommandsLayoutNV, Dispatch>( result,
-                                                                  indirectCommandsLayout,
-                                                                  VULKAN_HPP_NAMESPACE_STRING
-                                                                  "::Device::createIndirectCommandsLayoutNVUnique",
-                                                                  deleter );
+    ObjectDestroy<Device, Dispatch>                deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>(
+      result,
+      indirectCommandsLayout,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNVUnique",
+      deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -94081,6 +94272,7 @@ namespace VULKAN_HPP_NAMESPACE
                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                reinterpret_cast<VkPipelineCache *>( pPipelineCache ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94090,30 +94282,32 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
-    Result                              result = static_cast<Result>( d.vkCreatePipelineCache(
-      m_device,
-      reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
+    Result                              result = static_cast<Result>(
+      d.vkCreatePipelineCache( m_device,
+                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
     return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<PipelineCache, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
     Device::createPipelineCacheUnique( const PipelineCacheCreateInfo &     createInfo,
                                        Optional<const AllocationCallbacks> allocator,
                                        Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
-    Result                              result = static_cast<Result>( d.vkCreatePipelineCache(
-      m_device,
-      reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
-
+    Result                              result = static_cast<Result>(
+      d.vkCreatePipelineCache( m_device,
+                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<PipelineCache, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>(
       result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94132,6 +94326,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                 reinterpret_cast<VkPipelineLayout *>( pPipelineLayout ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94141,37 +94336,39 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
-    Result                               result = static_cast<Result>( d.vkCreatePipelineLayout(
-      m_device,
-      reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
+    Result                               result = static_cast<Result>(
+      d.vkCreatePipelineLayout( m_device,
+                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
     return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<PipelineLayout, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
     Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo &    createInfo,
                                         Optional<const AllocationCallbacks> allocator,
                                         Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
-    Result                               result = static_cast<Result>( d.vkCreatePipelineLayout(
-      m_device,
-      reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
-
+    Result                               result = static_cast<Result>(
+      d.vkCreatePipelineLayout( m_device,
+                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<PipelineLayout, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>(
       result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT * pCreateInfo,
                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
                                       VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT *                 pPrivateDataSlot,
@@ -94183,6 +94380,7 @@ namespace VULKAN_HPP_NAMESPACE
                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                     reinterpret_cast<VkPrivateDataSlotEXT *>( pPrivateDataSlot ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::type
@@ -94191,30 +94389,32 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot;
-    Result                                   result = static_cast<Result>( d.vkCreatePrivateDataSlotEXT(
-      m_device,
-      reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPrivateDataSlotEXT *>( &privateDataSlot ) ) );
+    Result                                   result = static_cast<Result>(
+      d.vkCreatePrivateDataSlotEXT( m_device,
+                                    reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkPrivateDataSlotEXT *>( &privateDataSlot ) ) );
     return createResultValue(
       result, privateDataSlot, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PrivateDataSlotEXT, Dispatch>>::type
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>>::type
     Device::createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfoEXT & createInfo,
                                             Optional<const AllocationCallbacks>  allocator,
                                             Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot;
-    Result                                   result = static_cast<Result>( d.vkCreatePrivateDataSlotEXT(
-      m_device,
-      reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPrivateDataSlotEXT *>( &privateDataSlot ) ) );
-
+    Result                                   result = static_cast<Result>(
+      d.vkCreatePrivateDataSlotEXT( m_device,
+                                    reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkPrivateDataSlotEXT *>( &privateDataSlot ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<PrivateDataSlotEXT, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>(
       result, privateDataSlot, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94232,6 +94432,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                      reinterpret_cast<VkQueryPool *>( pQueryPool ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94241,30 +94442,32 @@ namespace VULKAN_HPP_NAMESPACE
                              Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::QueryPool queryPool;
-    Result                          result = static_cast<Result>( d.vkCreateQueryPool(
-      m_device,
-      reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
+    Result                          result = static_cast<Result>(
+      d.vkCreateQueryPool( m_device,
+                           reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
     return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<QueryPool, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
     Device::createQueryPoolUnique( const QueryPoolCreateInfo &         createInfo,
                                    Optional<const AllocationCallbacks> allocator,
                                    Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::QueryPool queryPool;
-    Result                          result = static_cast<Result>( d.vkCreateQueryPool(
-      m_device,
-      reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
-
+    Result                          result = static_cast<Result>(
+      d.vkCreateQueryPool( m_device,
+                           reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<QueryPool, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>(
       result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94674,6 +94877,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                       reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94683,30 +94887,32 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>( d.vkCreateRenderPass(
-      m_device,
-      reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass( m_device,
+                            reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                            reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
     return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
     Device::createRenderPassUnique( const RenderPassCreateInfo &        createInfo,
                                     Optional<const AllocationCallbacks> allocator,
                                     Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>( d.vkCreateRenderPass(
-      m_device,
-      reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass( m_device,
+                            reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                            reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<RenderPass, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
       result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94724,6 +94930,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                        reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94733,30 +94940,32 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>( d.vkCreateRenderPass2(
-      m_device,
-      reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2( m_device,
+                             reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
     return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
     Device::createRenderPass2Unique( const RenderPassCreateInfo2 &       createInfo,
                                      Optional<const AllocationCallbacks> allocator,
                                      Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>( d.vkCreateRenderPass2(
-      m_device,
-      reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2( m_device,
+                             reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<RenderPass, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
       result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94775,6 +94984,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                 reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94784,30 +94994,32 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>( d.vkCreateRenderPass2KHR(
-      m_device,
-      reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2KHR( m_device,
+                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
     return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
     Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 &       createInfo,
                                         Optional<const AllocationCallbacks> allocator,
                                         Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>( d.vkCreateRenderPass2KHR(
-      m_device,
-      reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2KHR( m_device,
+                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<RenderPass, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
       result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94825,6 +95037,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                    reinterpret_cast<VkSampler *>( pSampler ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94834,30 +95047,32 @@ namespace VULKAN_HPP_NAMESPACE
                            Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Sampler sampler;
-    Result                        result = static_cast<Result>( d.vkCreateSampler(
-      m_device,
-      reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSampler *>( &sampler ) ) );
+    Result                        result = static_cast<Result>(
+      d.vkCreateSampler( m_device,
+                         reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
+                         reinterpret_cast<const VkAllocationCallbacks *>(
+                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                         reinterpret_cast<VkSampler *>( &sampler ) ) );
     return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Sampler, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
     Device::createSamplerUnique( const SamplerCreateInfo &           createInfo,
                                  Optional<const AllocationCallbacks> allocator,
                                  Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Sampler sampler;
-    Result                        result = static_cast<Result>( d.vkCreateSampler(
-      m_device,
-      reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSampler *>( &sampler ) ) );
-
+    Result                        result = static_cast<Result>(
+      d.vkCreateSampler( m_device,
+                         reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
+                         reinterpret_cast<const VkAllocationCallbacks *>(
+                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                         reinterpret_cast<VkSampler *>( &sampler ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Sampler, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>(
       result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94876,6 +95091,7 @@ namespace VULKAN_HPP_NAMESPACE
                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                         reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94885,31 +95101,33 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                         d ) const
   {
     VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
-    Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion(
-      m_device,
-      reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
+    Result                                       result = static_cast<Result>(
+      d.vkCreateSamplerYcbcrConversion( m_device,
+                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
     return createResultValue(
       result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
     Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
                                                 Optional<const AllocationCallbacks>      allocator,
                                                 Dispatch const &                         d ) const
   {
     VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
-    Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion(
-      m_device,
-      reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
-
+    Result                                       result = static_cast<Result>(
+      d.vkCreateSamplerYcbcrConversion( m_device,
+                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SamplerYcbcrConversion, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>(
       result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94928,6 +95146,7 @@ namespace VULKAN_HPP_NAMESPACE
                                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                            reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94940,15 +95159,17 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR(
       m_device,
       reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
     return createResultValue(
       result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
     Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
                                                    Optional<const AllocationCallbacks>      allocator,
                                                    Dispatch const &                         d ) const
@@ -94957,11 +95178,11 @@ namespace VULKAN_HPP_NAMESPACE
     Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR(
       m_device,
       reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
-
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SamplerYcbcrConversion, Dispatch>(
+    ObjectDestroy<Device, Dispatch>              deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>(
       result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -94979,6 +95200,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                      reinterpret_cast<VkSemaphore *>( pSemaphore ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -94988,30 +95210,32 @@ namespace VULKAN_HPP_NAMESPACE
                              Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Semaphore semaphore;
-    Result                          result = static_cast<Result>( d.vkCreateSemaphore(
-      m_device,
-      reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
+    Result                          result = static_cast<Result>(
+      d.vkCreateSemaphore( m_device,
+                           reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
     return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Semaphore, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
     Device::createSemaphoreUnique( const SemaphoreCreateInfo &         createInfo,
                                    Optional<const AllocationCallbacks> allocator,
                                    Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Semaphore semaphore;
-    Result                          result = static_cast<Result>( d.vkCreateSemaphore(
-      m_device,
-      reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
-
+    Result                          result = static_cast<Result>(
+      d.vkCreateSemaphore( m_device,
+                           reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Semaphore, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>(
       result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -95030,6 +95254,7 @@ namespace VULKAN_HPP_NAMESPACE
                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                               reinterpret_cast<VkShaderModule *>( pShaderModule ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -95039,30 +95264,32 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
-    Result                             result = static_cast<Result>( d.vkCreateShaderModule(
-      m_device,
-      reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
+    Result                             result = static_cast<Result>(
+      d.vkCreateShaderModule( m_device,
+                              reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
     return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<ShaderModule, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
     Device::createShaderModuleUnique( const ShaderModuleCreateInfo &      createInfo,
                                       Optional<const AllocationCallbacks> allocator,
                                       Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
-    Result                             result = static_cast<Result>( d.vkCreateShaderModule(
-      m_device,
-      reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
-
+    Result                             result = static_cast<Result>(
+      d.vkCreateShaderModule( m_device,
+                              reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<ShaderModule, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>(
       result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -95238,6 +95465,7 @@ namespace VULKAN_HPP_NAMESPACE
                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                               reinterpret_cast<VkSwapchainKHR *>( pSwapchain ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -95247,37 +95475,39 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
-    Result                             result = static_cast<Result>( d.vkCreateSwapchainKHR(
-      m_device,
-      reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
+    Result                             result = static_cast<Result>(
+      d.vkCreateSwapchainKHR( m_device,
+                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
     return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
     Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR &      createInfo,
                                       Optional<const AllocationCallbacks> allocator,
                                       Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
-    Result                             result = static_cast<Result>( d.vkCreateSwapchainKHR(
-      m_device,
-      reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
-
+    Result                             result = static_cast<Result>(
+      d.vkCreateSwapchainKHR( m_device,
+                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SwapchainKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>(
       result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
                                       VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
@@ -95289,6 +95519,7 @@ namespace VULKAN_HPP_NAMESPACE
                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                     reinterpret_cast<VkValidationCacheEXT *>( pValidationCache ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
@@ -95297,30 +95528,32 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
-    Result                                   result = static_cast<Result>( d.vkCreateValidationCacheEXT(
-      m_device,
-      reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
+    Result                                   result = static_cast<Result>(
+      d.vkCreateValidationCacheEXT( m_device,
+                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
     return createResultValue(
       result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ValidationCacheEXT, Dispatch>>::type
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
     Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
                                             Optional<const AllocationCallbacks>  allocator,
                                             Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
-    Result                                   result = static_cast<Result>( d.vkCreateValidationCacheEXT(
-      m_device,
-      reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
-
+    Result                                   result = static_cast<Result>(
+      d.vkCreateValidationCacheEXT( m_device,
+                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<ValidationCacheEXT, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>(
       result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -99893,10 +100126,11 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
-                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                     VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
+                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                              VULKAN_HPP_NAMESPACE::Fence *                     pFence,
+                              Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     return static_cast<Result>(
       d.vkRegisterDeviceEventEXT( m_device,
@@ -99904,6 +100138,7 @@ namespace VULKAN_HPP_NAMESPACE
                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                   reinterpret_cast<VkFence *>( pFence ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
@@ -99912,36 +100147,38 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>( d.vkRegisterDeviceEventEXT(
-      m_device,
-      reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFence *>( &fence ) ) );
+    Result                      result = static_cast<Result>(
+      d.vkRegisterDeviceEventEXT( m_device,
+                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>(
+                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                  reinterpret_cast<VkFence *>( &fence ) ) );
     return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
     Device::registerEventEXTUnique( const DeviceEventInfoEXT &          deviceEventInfo,
                                     Optional<const AllocationCallbacks> allocator,
                                     Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>( d.vkRegisterDeviceEventEXT(
-      m_device,
-      reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFence *>( &fence ) ) );
-
+    Result                      result = static_cast<Result>(
+      d.vkRegisterDeviceEventEXT( m_device,
+                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>(
+                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                  reinterpret_cast<VkFence *>( &fence ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Fence, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
       result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
                                      const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -99955,6 +100192,7 @@ namespace VULKAN_HPP_NAMESPACE
                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                    reinterpret_cast<VkFence *>( pFence ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
@@ -99964,32 +100202,34 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>( d.vkRegisterDisplayEventEXT(
-      m_device,
-      static_cast<VkDisplayKHR>( display ),
-      reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFence *>( &fence ) ) );
+    Result                      result = static_cast<Result>(
+      d.vkRegisterDisplayEventEXT( m_device,
+                                   static_cast<VkDisplayKHR>( display ),
+                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkFence *>( &fence ) ) );
     return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
     Device::registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
                                            const DisplayEventInfoEXT &         displayEventInfo,
                                            Optional<const AllocationCallbacks> allocator,
                                            Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>( d.vkRegisterDisplayEventEXT(
-      m_device,
-      static_cast<VkDisplayKHR>( display ),
-      reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkFence *>( &fence ) ) );
-
+    Result                      result = static_cast<Result>(
+      d.vkRegisterDisplayEventEXT( m_device,
+                                   static_cast<VkDisplayKHR>( display ),
+                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkFence *>( &fence ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Fence, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
       result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100036,6 +100276,25 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release(
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
+      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
+      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
@@ -100532,6 +100791,7 @@ namespace VULKAN_HPP_NAMESPACE
                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                    reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -100541,30 +100801,32 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateAndroidSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
                                              Optional<const AllocationCallbacks> allocator,
                                              Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateAndroidSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100572,7 +100834,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Instance::createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
                                             VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
@@ -100584,6 +100846,7 @@ namespace VULKAN_HPP_NAMESPACE
                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                         reinterpret_cast<VkDebugReportCallbackEXT *>( pCallback ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
@@ -100592,37 +100855,39 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                         d ) const
   {
     VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
-    Result                                       result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT(
-      m_instance,
-      reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugReportCallbackEXT( m_instance,
+                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
     return createResultValue(
       result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugReportCallbackEXT, Dispatch>>::type
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
     Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
                                                   Optional<const AllocationCallbacks>      allocator,
                                                   Dispatch const &                         d ) const
   {
     VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
-    Result                                       result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT(
-      m_instance,
-      reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
-
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugReportCallbackEXT( m_instance,
+                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DebugReportCallbackEXT, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>(
       result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Instance::createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
                                             VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
@@ -100634,6 +100899,7 @@ namespace VULKAN_HPP_NAMESPACE
                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                         reinterpret_cast<VkDebugUtilsMessengerEXT *>( pMessenger ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
@@ -100642,30 +100908,32 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                         d ) const
   {
     VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
-    Result                                       result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT(
-      m_instance,
-      reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugUtilsMessengerEXT( m_instance,
+                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
     return createResultValue(
       result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT, Dispatch>>::type
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
     Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
                                                   Optional<const AllocationCallbacks>      allocator,
                                                   Dispatch const &                         d ) const
   {
     VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
-    Result                                       result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT(
-      m_instance,
-      reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
-
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugUtilsMessengerEXT( m_instance,
+                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DebugUtilsMessengerEXT, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>(
       result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100685,6 +100953,7 @@ namespace VULKAN_HPP_NAMESPACE
                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                     reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -100694,30 +100963,32 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateDirectFBSurfaceEXT(
-      m_instance,
-      reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateDirectFBSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
                                               Optional<const AllocationCallbacks>  allocator,
                                               Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateDirectFBSurfaceEXT(
-      m_instance,
-      reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateDirectFBSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100737,6 +101008,7 @@ namespace VULKAN_HPP_NAMESPACE
                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                         reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -100746,30 +101018,32 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
+                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
                                                   Optional<const AllocationCallbacks> allocator,
                                                   Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
+                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100788,6 +101062,7 @@ namespace VULKAN_HPP_NAMESPACE
                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                     reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -100797,30 +101072,32 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT(
-      m_instance,
-      reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateHeadlessSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
                                               Optional<const AllocationCallbacks>  allocator,
                                               Dispatch const &                     d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT(
-      m_instance,
-      reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateHeadlessSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100840,6 +101117,7 @@ namespace VULKAN_HPP_NAMESPACE
                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -100849,30 +101127,32 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateIOSSurfaceMVK(
-      m_instance,
-      reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateIOSSurfaceMVK( m_instance,
+                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK &     createInfo,
                                          Optional<const AllocationCallbacks> allocator,
                                          Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateIOSSurfaceMVK(
-      m_instance,
-      reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateIOSSurfaceMVK( m_instance,
+                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100893,6 +101173,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                          reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -100905,28 +101186,30 @@ namespace VULKAN_HPP_NAMESPACE
     Result                           result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
       m_instance,
       reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
                                                    Optional<const AllocationCallbacks>       allocator,
                                                    Dispatch const &                          d ) const
   {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
+    VULKAN_HPP_NAMESPACE::SurfaceKHR  surface;
+    Result                            result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
       m_instance,
       reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -100947,6 +101230,7 @@ namespace VULKAN_HPP_NAMESPACE
                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                  reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -100956,30 +101240,32 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK(
-      m_instance,
-      reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateMacOSSurfaceMVK( m_instance,
+                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK &   createInfo,
                                            Optional<const AllocationCallbacks> allocator,
                                            Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK(
-      m_instance,
-      reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateMacOSSurfaceMVK( m_instance,
+                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101000,6 +101286,7 @@ namespace VULKAN_HPP_NAMESPACE
                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                  reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101009,30 +101296,32 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateMetalSurfaceEXT(
-      m_instance,
-      reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateMetalSurfaceEXT( m_instance,
+                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT &   createInfo,
                                            Optional<const AllocationCallbacks> allocator,
                                            Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateMetalSurfaceEXT(
-      m_instance,
-      reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateMetalSurfaceEXT( m_instance,
+                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101053,6 +101342,7 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
       reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101065,28 +101355,30 @@ namespace VULKAN_HPP_NAMESPACE
     Result                           result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
       m_instance,
       reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
                                                       Optional<const AllocationCallbacks>          allocator,
                                                       Dispatch const &                             d ) const
   {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
+    VULKAN_HPP_NAMESPACE::SurfaceKHR  surface;
+    Result                            result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
       m_instance,
       reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
       reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101106,6 +101398,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                        reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101115,30 +101408,32 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateViSurfaceNN(
-      m_instance,
-      reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateViSurfaceNN( m_instance,
+                             reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN &       createInfo,
                                        Optional<const AllocationCallbacks> allocator,
                                        Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateViSurfaceNN(
-      m_instance,
-      reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateViSurfaceNN( m_instance,
+                             reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101159,6 +101454,7 @@ namespace VULKAN_HPP_NAMESPACE
                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                    reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101168,30 +101464,32 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateWaylandSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
                                              Optional<const AllocationCallbacks> allocator,
                                              Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateWaylandSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101212,6 +101510,7 @@ namespace VULKAN_HPP_NAMESPACE
                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                  reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101221,30 +101520,32 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateWin32SurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateWin32SurfaceKHR( m_instance,
+                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR &   createInfo,
                                            Optional<const AllocationCallbacks> allocator,
                                            Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateWin32SurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateWin32SurfaceKHR( m_instance,
+                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101265,6 +101566,7 @@ namespace VULKAN_HPP_NAMESPACE
                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101274,30 +101576,32 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateXcbSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateXcbSurfaceKHR( m_instance,
+                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR &     createInfo,
                                          Optional<const AllocationCallbacks> allocator,
                                          Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateXcbSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateXcbSurfaceKHR( m_instance,
+                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101318,6 +101622,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101327,30 +101632,32 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateXlibSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    Result                           result = static_cast<Result>(
+      d.vkCreateXlibSurfaceKHR( m_instance,
+                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" );
   }
+
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
     Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR &    createInfo,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateXlibSurfaceKHR(
-      m_instance,
-      reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-
+    Result                           result = static_cast<Result>(
+      d.vkCreateXlibSurfaceKHR( m_instance,
+                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
     ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
       result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique", deleter );
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101857,6 +102164,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                                   reinterpret_cast<VkDevice *>( pDevice ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
@@ -101865,30 +102173,32 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Device device;
-    Result                       result = static_cast<Result>( d.vkCreateDevice(
-      m_physicalDevice,
-      reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDevice *>( &device ) ) );
+    Result                       result = static_cast<Result>(
+      d.vkCreateDevice( m_physicalDevice,
+                        reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                        reinterpret_cast<VkDevice *>( &device ) ) );
     return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" );
   }
+
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<Device, Dispatch>>::type
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
     PhysicalDevice::createDeviceUnique( const DeviceCreateInfo &            createInfo,
                                         Optional<const AllocationCallbacks> allocator,
                                         Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Device device;
-    Result                       result = static_cast<Result>( d.vkCreateDevice(
-      m_physicalDevice,
-      reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDevice *>( &device ) ) );
-
+    Result                       result = static_cast<Result>(
+      d.vkCreateDevice( m_physicalDevice,
+                        reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                        reinterpret_cast<VkDevice *>( &device ) ) );
     ObjectDestroy<NoParent, Dispatch> deleter( allocator, d );
-    return createResultValue<Device, Dispatch>(
+    return createResultValue<VULKAN_HPP_NAMESPACE::Device, Dispatch>(
       result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -101909,6 +102219,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
                                 reinterpret_cast<VkDisplayModeKHR *>( pMode ) ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@@ -101919,15 +102230,39 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
-    Result                               result = static_cast<Result>( d.vkCreateDisplayModeKHR(
-      m_physicalDevice,
-      static_cast<VkDisplayKHR>( display ),
-      reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
+    Result                               result = static_cast<Result>(
+      d.vkCreateDisplayModeKHR( m_physicalDevice,
+                                static_cast<VkDisplayKHR>( display ),
+                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
     return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" );
   }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
+    PhysicalDevice::createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
+                                                const DisplayModeCreateInfoKHR &    createInfo,
+                                                Optional<const AllocationCallbacks> allocator,
+                                                Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
+    Result                               result = static_cast<Result>(
+      d.vkCreateDisplayModeKHR( m_physicalDevice,
+                                static_cast<VkDisplayKHR>( display ),
+                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
+    ObjectDestroy<PhysicalDevice, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>(
+      result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
@@ -104939,14 +105274,16 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display *                          dpy,
-                                                                     RROutput                           rrOutput,
-                                                                     VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
-                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getRandROutputDisplayEXT( Display *                          dpy,
+                                              RROutput                           rrOutput,
+                                              VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
+                                              Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
   {
     return static_cast<Result>(
       d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
@@ -104958,8 +105295,22 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" );
   }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
+    PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result                           result = static_cast<Result>(
+      d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>(
+      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>