diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 0217022..4f90552 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -1234,30 +1234,44 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
       {
         // no return parameter
         std::vector<size_t> constPointerParamIndices = determineConstPointerParamIndices( commandData.params );
-#if 0
-        if ( !constPointerParamIndices.empty() &&
-             ( std::find_if(
-                 constPointerParamIndices.begin(), constPointerParamIndices.end(), [&commandData]( size_t idx ) {
-                   return commandData.params[idx].type.type == "void";
-                 } ) == constPointerParamIndices.end() ) )
-#else
-        if ( !constPointerParamIndices.empty() && ( commandData.successCodes.size() == 1 ) )
-#endif
+        if ( !constPointerParamIndices.empty() )
         {
-          // no pointer-in parameter and just one success code
-          appendCommandSimple( str, name, commandData, definition );
-          return;
+          // with const-pointer(s),
+          switch ( commandData.successCodes.size() )
+          {
+            case 0:
+              // no success codes at all
+              if ( ( commandData.returnType == "void" ) &&
+                   std::find_if(
+                     constPointerParamIndices.begin(), constPointerParamIndices.end(), [&commandData]( size_t idx ) {
+                       return commandData.params[idx].type.type == "void";
+                     } ) == constPointerParamIndices.end() )
+              {
+                // command returns void, and the const pointer(s) are void-pointers and thus can't be change from
+                // by-pointer to by-reference
+                appendCommandSimpleVoid( str, name, commandData, definition );
+                return;
+              }
+              break;
+            case 1:
+              // just one success code
+              appendCommandSimple( str, name, commandData, definition );
+              return;
+            default: break;
+          }
         }
       }
     }
     break;
     case 1:
     {
+      // just one vector parameter
       auto vectorParamIndexIt = vectorParamIndices.begin();
       if ( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() &&
            ( commandData.params[vectorParamIndexIt->first].type.type == "void" ) &&
            commandData.params[vectorParamIndexIt->second].type.isValue() )
       {
+        // the vector is a non-const pointer to void (that is, a return parameter), and the size is given by value
         appendCommandGetVector( str, name, commandData, vectorParamIndices, definition );
         return;
       }
@@ -1265,6 +1279,7 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
     break;
     case 2:
     {
+      // two vector parameters
       auto                           firstVectorParam  = vectorParamIndices.begin();
       auto                           secondVectorParam = firstVectorParam++;
       std::vector<ParamData> const & params            = commandData.params;
@@ -1273,6 +1288,8 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
            params[secondVectorParam->first].type.isNonConstPointer() &&
            params[firstVectorParam->second].type.isNonConstPointer() )
       {
+        // both vectors are non-const pointer (that is, return parameters), and share the same size parameter, which in
+        // turn is a non-const pointer
         appendCommandEnumerateTwoVectors( str, name, commandData, vectorParamIndices, definition );
         return;
       }
@@ -1655,6 +1672,44 @@ ${leave}
   }
 }
 
+void VulkanHppGenerator::appendCommandSimpleVoid( std::string &       str,
+                                                  std::string const & name,
+                                                  CommandData const & commandData,
+                                                  bool                definition ) const
+{
+  const std::string functionTemplate = R"(
+${enter}${commandStandard}${newlineOnDefinition}
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+${commandEnhanced}
+#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", constructCommandSimpleVoid( name, commandData, definition ) },
+                             { "commandStandard", constructCommandStandardVoid( name, commandData, definition ) },
+                             { "enter", enter },
+                             { "leave", leave },
+                             { "newlineOnDefinition", definition ? "\n" : "" } } ) );
+
+  if ( !commandData.aliasData.empty() )
+  {
+    CommandData aliasCommandData = commandData;
+    aliasCommandData.aliasData.clear();
+    for ( auto const & ad : commandData.aliasData )
+    {
+      aliasCommandData.extensions = ad.second.extensions;
+      aliasCommandData.feature    = ad.second.feature;
+      aliasCommandData.xmlLine    = ad.second.xmlLine;
+      appendCommandSimpleVoid( str, ad.first, aliasCommandData, definition );
+    }
+  }
+}
+
 void VulkanHppGenerator::appendDispatchLoaderDynamic( std::string & str )
 {
   str += R"(
@@ -3618,6 +3673,7 @@ void VulkanHppGenerator::appendStructCompareOperators( std::string &
 
 std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<ParamData> const & params,
                                                                std::set<size_t> const &       skippedParams,
+                                                               bool                           definition,
                                                                bool                           withAllocators ) const
 {
   assert( *skippedParams.begin() == 0 );
@@ -3630,19 +3686,29 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
       {
         if ( params[i].type.isConstPointer() )
         {
-          argumentList += "const " + stripPrefix( params[i].type.type, "Vk" ) + " & " +
-                          startLowerCase( stripPrefix( params[i].name, "p" ) ) + ", ";
+          if ( params[i].optional )
+          {
+            assert( params[i].type.isConstPointer() );
+            argumentList += "Optional<const " + stripPrefix( params[i].type.type, "Vk" ) + "> " +
+                            startLowerCase( stripPrefix( params[i].name, "p" ) +
+                                            ( definition ? "" : " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT" ) );
+          }
+          else
+          {
+            argumentList += "const " + stripPrefix( params[i].type.type, "Vk" ) + " & " +
+                            startLowerCase( stripPrefix( params[i].name, "p" ) );
+          }
         }
         else
         {
-          argumentList +=
-            "VULKAN_HPP_NAMESPACE::" + stripPrefix( params[i].type.type, "Vk" ) + " " + params[i].name + ", ";
+          argumentList += "VULKAN_HPP_NAMESPACE::" + stripPrefix( params[i].type.type, "Vk" ) + " " + params[i].name;
         }
       }
       else
       {
-        argumentList += params[i].type.compose() + " " + params[i].name + ", ";
+        argumentList += params[i].type.compose() + " " + params[i].name;
       }
+      argumentList += ", ";
     }
   }
   if ( withAllocators )
@@ -3656,7 +3722,8 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
       }
     }
   }
-  argumentList += "Dispatch const & d ";
+  argumentList +=
+    std::string( "Dispatch const & d " ) + ( definition ? "" : " VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT" );
   return argumentList;
 }
 
@@ -3772,6 +3839,7 @@ std::string
   std::string argumentList = constructArgumentListEnhanced(
     commandData.params,
     { 0, firstVectorParamIt->second, firstVectorParamIt->first, secondVectorParamIt->first },
+    definition,
     withAllocators );
   std::string commandName        = determineCommandName( name, commandData.params[0].type.type );
   std::string nodiscard          = constructNoDiscardEnhanced( commandData );
@@ -3845,7 +3913,7 @@ std::string
   {
     const std::string functionTemplate =
       R"(    template <typename ${templateTypeFirst}Allocator = std::allocator<${templateTypeFirst}>, typename ${templateTypeSecond}Allocator = std::allocator<${templateTypeSecond}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${withAllocatorTypenameCheck}>
-    ${nodiscard}typename ResultValueType<std::pair<std::vector<${templateTypeFirst}, ${templateTypeFirst}Allocator>, std::vector<${templateTypeSecond}, ${templateTypeSecond}Allocator>>>::type ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;)";
+    ${nodiscard}typename ResultValueType<std::pair<std::vector<${templateTypeFirst}, ${templateTypeFirst}Allocator>, std::vector<${templateTypeSecond}, ${templateTypeSecond}Allocator>>>::type ${commandName}( ${argumentList} ) const;)";
 
     std::string withAllocatorsTypenameCheck =
       ", typename B1 = " + templateTypeFirst + "Allocator, typename B2 = " + templateTypeSecond +
@@ -3876,7 +3944,7 @@ std::string VulkanHppGenerator::constructCommandEnumerateTwoVectorsDeprecated(
   size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, true );
 
   std::string argumentList = constructFunctionHeaderArgumentsEnhanced(
-    commandData, returnParamIndex, returnParamIndex, vectorParamIndices, false, false, withAllocators );
+    commandData, returnParamIndex, returnParamIndex, vectorParamIndices, false, !definition, withAllocators );
   std::string commandName  = determineCommandName( name, commandData.params[0].type.type );
   std::string nodiscard    = constructNoDiscardEnhanced( commandData );
   std::string returnType   = determineEnhancedReturnType( commandData, returnParamIndex, vectorParamIndices, false );
@@ -3923,7 +3991,7 @@ std::string VulkanHppGenerator::constructCommandEnumerateTwoVectorsDeprecated(
   {
     const std::string functionTemplate =
       R"(    template <typename Allocator = std::allocator<${templateType}>, typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${typeCheck}>
-    ${nodiscard}typename ResultValueType<${returnType}>::type ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;)";
+    ${nodiscard}typename ResultValueType<${returnType}>::type ${commandName}( ${argumentList} ) const;)";
 
     std::string typeCheck =
       withAllocators ? ", typename B = Allocator, typename std::enable_if<std::is_same<typename B::value_type, " +
@@ -3952,10 +4020,11 @@ std::string VulkanHppGenerator::constructCommandGetVector( std::string const &
   std::string str;
 
   size_t      vectorParamIndex = vectorParamIndices.begin()->first;
-  std::string argumentList     = constructArgumentListEnhanced( commandData.params, { 0, vectorParamIndex }, false );
-  std::string commandName      = determineCommandName( name, commandData.params[0].type.type );
-  std::string nodiscard        = constructNoDiscardEnhanced( commandData );
-  std::string returnType       = constructReturnType( commandData, "std::vector<T,Allocator>" );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandData.params, { 0, vectorParamIndex }, definition, false );
+  std::string commandName = determineCommandName( name, commandData.params[0].type.type );
+  std::string nodiscard   = constructNoDiscardEnhanced( commandData );
+  std::string returnType  = constructReturnType( commandData, "std::vector<T,Allocator>" );
 
   if ( definition )
   {
@@ -3987,7 +4056,7 @@ std::string VulkanHppGenerator::constructCommandGetVector( std::string const &
   {
     std::string const functionTemplate =
       R"(    template <typename T, typename Allocator = std::allocator<T>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    ${nodiscard}${returnType} ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;)";
+    ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
 
     str = replaceWithMap( functionTemplate,
                           std::map<std::string, std::string>( { { "argumentList", argumentList },
@@ -4009,7 +4078,7 @@ std::string
 
   std::map<size_t, size_t>::const_iterator vectorParamIndexIt = vectorParamIndices.begin();
   std::string                              argumentList       = constructFunctionHeaderArgumentsEnhanced(
-    commandData, INVALID_INDEX, vectorParamIndexIt->first, vectorParamIndices, false, false, false );
+    commandData, INVALID_INDEX, vectorParamIndexIt->first, vectorParamIndices, false, !definition, false );
   std::string commandName = determineCommandName( name, commandData.params[0].type.type );
   std::string nodiscard   = constructNoDiscardEnhanced( commandData );
   std::string returnType  = constructReturnType( commandData, "void" );
@@ -4049,7 +4118,7 @@ std::string
   {
     std::string const functionTemplate =
       R"(    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    ${nodiscard}${returnType} ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;)";
+    ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
 
     str = replaceWithMap( functionTemplate,
                           std::map<std::string, std::string>( { { "argumentList", argumentList },
@@ -4073,7 +4142,7 @@ std::string VulkanHppGenerator::constructCommandGetVectorSingular( std::string c
   size_t      vectorParamIndex = vectorParamIndices.begin()->first;
   size_t      sizeParamIndex   = vectorParamIndices.begin()->second;
   std::string argumentList =
-    constructArgumentListEnhanced( commandData.params, { 0, sizeParamIndex, vectorParamIndex }, false );
+    constructArgumentListEnhanced( commandData.params, { 0, sizeParamIndex, vectorParamIndex }, definition, false );
   std::string commandName = stripPluralS( determineCommandName( name, commandData.params[0].type.type ) );
   std::string nodiscard   = constructNoDiscardEnhanced( commandData );
   std::string returnType  = constructReturnType( commandData, "T" );
@@ -4106,7 +4175,7 @@ std::string VulkanHppGenerator::constructCommandGetVectorSingular( std::string c
   {
     std::string const functionTemplate =
       R"(    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    ${nodiscard}${returnType} ${commandName}( ${argumentList}  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;)";
+    ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
 
     str = replaceWithMap( functionTemplate,
                           std::map<std::string, std::string>( { { "argumentList", argumentList },
@@ -4124,7 +4193,7 @@ std::string VulkanHppGenerator::constructCommandSimple( std::string const & name
 {
   std::string str;
 
-  std::string argumentList = constructArgumentListEnhanced( commandData.params, { 0 }, false );
+  std::string argumentList = constructArgumentListEnhanced( commandData.params, { 0 }, definition, false );
   std::string commandName  = determineCommandName( name, commandData.params[0].type.type );
   std::string nodiscard    = constructNoDiscardEnhanced( commandData );
   std::string returnType   = constructReturnType( commandData, "void" );
@@ -4142,7 +4211,7 @@ std::string VulkanHppGenerator::constructCommandSimple( std::string const & name
     str = replaceWithMap( functionTemplate,
                           std::map<std::string, std::string>(
                             { { "argumentList", argumentList },
-                              { "callArguments", constructCallArguments( commandData.params, {}, true, true, false ) },
+                              { "callArguments", constructCallArguments( commandData.params, {}, false, true, false ) },
                               { "className", stripPrefix( commandData.handle, "Vk" ) },
                               { "commandName", commandName },
                               { "nodiscard", nodiscard },
@@ -4153,7 +4222,7 @@ std::string VulkanHppGenerator::constructCommandSimple( std::string const & name
   {
     std::string const functionTemplate =
       R"(    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    ${nodiscard}${returnType} ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;)";
+    ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
 
     str = replaceWithMap( functionTemplate,
                           std::map<std::string, std::string>( { { "argumentList", argumentList },
@@ -4165,6 +4234,46 @@ std::string VulkanHppGenerator::constructCommandSimple( std::string const & name
   return str;
 }
 
+std::string VulkanHppGenerator::constructCommandSimpleVoid( std::string const & name,
+                                                            CommandData const & commandData,
+                                                            bool                definition ) const
+{
+  std::string str;
+
+  std::string argumentList = constructArgumentListEnhanced( commandData.params, { 0 }, definition, false );
+  std::string commandName  = determineCommandName( name, commandData.params[0].type.type );
+
+  if ( definition )
+  {
+    std::string const functionTemplate =
+      R"(  template <typename Dispatch>
+  VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.${vkCommand}( ${callArguments} );
+  })";
+
+    str = replaceWithMap( functionTemplate,
+                          std::map<std::string, std::string>(
+                            { { "argumentList", argumentList },
+                              { "callArguments", constructCallArguments( commandData.params, {}, false, true, false ) },
+                              { "className", stripPrefix( commandData.handle, "Vk" ) },
+                              { "commandName", commandName },
+                              { "vkCommand", name } } ) );
+  }
+  else
+  {
+    std::string const functionTemplate =
+      R"(    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;)";
+
+    str = replaceWithMap(
+      functionTemplate,
+      std::map<std::string, std::string>( { { "argumentList", argumentList }, { "commandName", commandName } } ) );
+  }
+
+  return str;
+}
+
 std::string VulkanHppGenerator::constructCommandStandard( std::string const & name,
                                                           CommandData const & commandData,
                                                           bool                definition ) const
@@ -4208,6 +4317,46 @@ std::string VulkanHppGenerator::constructCommandStandard( std::string const & na
   return str;
 }
 
+std::string VulkanHppGenerator::constructCommandStandardVoid( std::string const & name,
+                                                              CommandData const & commandData,
+                                                              bool                definition ) const
+{
+  std::string str;
+
+  std::string argumentList = constructArgumentListStandard( commandData.params, { 0 } );
+  std::string commandName  = determineCommandName( name, commandData.params[0].type.type );
+
+  if ( definition )
+  {
+    std::string const functionTemplate =
+      R"(  template <typename Dispatch>
+  VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.${vkCommand}( ${callArguments} );
+  })";
+
+    str = replaceWithMap( functionTemplate,
+                          std::map<std::string, std::string>( {
+                            { "argumentList", argumentList },
+                            { "callArguments", constructCallArguments( commandData.params, {}, false, false, false ) },
+                            { "className", stripPrefix( commandData.handle, "Vk" ) },
+                            { "commandName", commandName },
+                            { "vkCommand", name },
+                          } ) );
+  }
+  else
+  {
+    std::string const functionTemplate =
+      R"(    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;)";
+
+    str = replaceWithMap(
+      functionTemplate,
+      std::map<std::string, std::string>( { { "argumentList", argumentList }, { "commandName", commandName } } ) );
+  }
+  return str;
+}
+
 std::string
   VulkanHppGenerator::constructConstexprString( std::pair<std::string, StructureData> const & structData ) const
 {
@@ -4413,7 +4562,7 @@ std::string
     str += "Allocator const& vectorAllocator, ";
   }
   str += "Dispatch const &d";
-  if ( withDefaults && !withAllocator )
+  if ( withDefaults )
   {
     str += " VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT";
   }
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 12fbf49..5d9f090 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -330,6 +330,10 @@ private:
                                    std::string const & name,
                                    CommandData const & commandData,
                                    bool                definition ) const;
+  void        appendCommandSimpleVoid( std::string &       str,
+                                       std::string const & name,
+                                       CommandData const & commandData,
+                                       bool                definition ) const;
   void        appendDispatchLoaderDynamicCommand( std::string &       str,
                                                   std::string &       emptyFunctions,
                                                   std::string &       deviceFunctions,
@@ -511,6 +515,7 @@ private:
                                  std::set<std::string> const & childrenTypes ) const;
   std::string constructArgumentListEnhanced( std::vector<ParamData> const & params,
                                              std::set<size_t> const &       skippedParams,
+                                             bool                           definition,
                                              bool                           withAllocators ) const;
   std::string constructArgumentListStandard( std::vector<ParamData> const & params,
                                              std::set<size_t> const &       skippedParams ) const;
@@ -543,8 +548,12 @@ private:
                                                  bool                             definition ) const;
   std::string
     constructCommandSimple( std::string const & name, CommandData const & commandData, bool definition ) const;
+  std::string
+    constructCommandSimpleVoid( std::string const & name, CommandData const & commandData, bool definition ) const;
   std::string
     constructCommandStandard( std::string const & name, CommandData const & commandData, bool definition ) const;
+  std::string
+    constructCommandStandardVoid( std::string const & name, CommandData const & commandData, bool definition ) const;
   std::string constructConstexprString( std::pair<std::string, StructureData> const & structData ) const;
   std::string constructFunctionBodyEnhanced( std::string const &              indentation,
                                              std::string const &              name,
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 5eeed66..18d80d5 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -46609,8 +46609,9 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0>
-    std::vector<CheckpointDataNV, Allocator> getCheckpointDataNV( Allocator const & vectorAllocator,
-                                                                  Dispatch const &  d ) const;
+    std::vector<CheckpointDataNV, Allocator>
+      getCheckpointDataNV( Allocator const &  vectorAllocator,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -50796,7 +50797,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<CommandBuffer, Allocator>>::type
       allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
                               Allocator const &                 vectorAllocator,
-                              Dispatch const &                  d ) const;
+                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename Allocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
@@ -50814,7 +50815,7 @@ namespace VULKAN_HPP_NAMESPACE
       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator>>::type
       allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
                                     Allocator const &                 vectorAllocator,
-                                    Dispatch const &                  d ) const;
+                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -50836,7 +50837,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<DescriptorSet, Allocator>>::type
       allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
                               Allocator const &                 vectorAllocator,
-                              Dispatch const &                  d ) const;
+                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename Allocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
@@ -50854,7 +50855,7 @@ namespace VULKAN_HPP_NAMESPACE
       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator>>::type
       allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
                                     Allocator const &                 vectorAllocator,
-                                    Dispatch const &                  d ) const;
+                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -51192,7 +51193,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
                                                  Optional<const AllocationCallbacks>                                       allocator,
                                                  Allocator const &                                                         vectorAllocator,
-                                                 Dispatch const &                                                          d ) const;
+                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createComputePipeline(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51219,7 +51220,7 @@ namespace VULKAN_HPP_NAMESPACE
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
                            Optional<const AllocationCallbacks>                                       allocator,
                            Allocator const &                                                         vectorAllocator,
-                           Dispatch const &                                                          d ) const;
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createComputePipelineUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51432,8 +51433,8 @@ namespace VULKAN_HPP_NAMESPACE
                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
                                                   Optional<const AllocationCallbacks>                                        allocator,
-                                                  Allocator const & vectorAllocator,
-                                                  Dispatch const &  d ) const;
+                                                  Allocator const &  vectorAllocator,
+                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51460,7 +51461,7 @@ namespace VULKAN_HPP_NAMESPACE
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
                            Optional<const AllocationCallbacks>                                        allocator,
                            Allocator const &                                                          vectorAllocator,
-                           Dispatch const &                                                           d ) const;
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createGraphicsPipelineUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51651,7 +51652,7 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
       Optional<const AllocationCallbacks>                                             allocator,
       Allocator const &                                                               vectorAllocator,
-      Dispatch const &                                                                d ) const;
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineKHR(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51678,7 +51679,7 @@ namespace VULKAN_HPP_NAMESPACE
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
                            Optional<const AllocationCallbacks>                                             allocator,
                            Allocator const &                                                               vectorAllocator,
-                           Dispatch const &                                                                d ) const;
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineKHRUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51713,7 +51714,7 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
       Optional<const AllocationCallbacks>                                            allocator,
       Allocator const &                                                              vectorAllocator,
-      Dispatch const &                                                               d ) const;
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineNV(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51740,7 +51741,7 @@ namespace VULKAN_HPP_NAMESPACE
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
                            Optional<const AllocationCallbacks>                                            allocator,
                            Allocator const &                                                              vectorAllocator,
-                           Dispatch const &                                                               d ) const;
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineNVUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache           pipelineCache,
@@ -51952,7 +51953,7 @@ namespace VULKAN_HPP_NAMESPACE
       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                  Optional<const AllocationCallbacks>                                    allocator,
                                  Allocator const &                                                      vectorAllocator,
-                                 Dispatch const &                                                       d ) const;
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR(
       const SwapchainCreateInfoKHR &                createInfo,
@@ -51978,7 +51979,7 @@ namespace VULKAN_HPP_NAMESPACE
         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
         Optional<const AllocationCallbacks>                                    allocator,
         Allocator const &                                                      vectorAllocator,
-        Dispatch const &                                                       d ) const;
+        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
       createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
@@ -53379,8 +53380,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename B                         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
                                       int>::type = 0>
-    std::vector<SparseImageMemoryRequirements, Allocator> getImageSparseMemoryRequirements(
-      VULKAN_HPP_NAMESPACE::Image image, Allocator const & vectorAllocator, Dispatch const & d ) const;
+    std::vector<SparseImageMemoryRequirements, Allocator>
+      getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
+                                        Allocator const &           vectorAllocator,
+                                        Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53400,8 +53403,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename B                         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
                                       int>::type = 0>
-    std::vector<SparseImageMemoryRequirements2, Allocator> getImageSparseMemoryRequirements2(
-      const ImageSparseMemoryRequirementsInfo2 & info, Allocator const & vectorAllocator, Dispatch const & d ) const;
+    std::vector<SparseImageMemoryRequirements2, Allocator>
+      getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
+                                         Allocator const &                          vectorAllocator,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53421,8 +53426,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename B                         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
                                       int>::type = 0>
-    std::vector<SparseImageMemoryRequirements2, Allocator> getImageSparseMemoryRequirements2KHR(
-      const ImageSparseMemoryRequirementsInfo2 & info, Allocator const & vectorAllocator, Dispatch const & d ) const;
+    std::vector<SparseImageMemoryRequirements2, Allocator>
+      getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
+                                            Allocator const &                          vectorAllocator,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53585,7 +53592,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, Allocator>>::type
       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
                                        Allocator const &                  vectorAllocator,
-                                       Dispatch const &                   d ) const;
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53615,8 +53622,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type getPipelineCacheData(
-      VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Allocator const & vectorAllocator, Dispatch const & d ) const;
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type
+      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                            Allocator const &                   vectorAllocator,
+                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53643,7 +53652,8 @@ namespace VULKAN_HPP_NAMESPACE
       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, Allocator>>::type
       getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
                                                        Allocator const &                 vectorAllocator,
-                                                       Dispatch const &                  d ) const;
+                                                       Dispatch const & d
+                                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53666,7 +53676,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, Allocator>>::type
       getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
                                           Allocator const &       vectorAllocator,
-                                          Dispatch const &        d ) const;
+                                          Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53689,7 +53699,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, Allocator>>::type
       getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
                                           Allocator const &                 vectorAllocator,
-                                          Dispatch const &                  d ) const;
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53952,7 +53962,7 @@ namespace VULKAN_HPP_NAMESPACE
                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
                         Allocator const &                         vectorAllocator,
-                        Dispatch const &                          d ) const;
+                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -53984,8 +53994,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, Allocator>>::type getSwapchainImagesKHR(
-      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Allocator const & vectorAllocator, Dispatch const & d ) const;
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, Allocator>>::type
+      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                             Allocator const &                  vectorAllocator,
+                             Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -54017,7 +54029,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type
       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
                                  Allocator const &                        vectorAllocator,
-                                 Dispatch const &                         d ) const;
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59189,7 +59201,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, Allocator>>::type
       enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
                                           Allocator const &           vectorAllocator,
-                                          Dispatch const &            d ) const;
+                                          Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59207,7 +59219,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
-      enumerateDeviceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      enumerateDeviceLayerProperties( Allocator const &  vectorAllocator,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59282,7 +59295,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModeProperties2KHR, Allocator>>::type
       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
                                     Allocator const &                vectorAllocator,
-                                    Dispatch const &                 d ) const;
+                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59305,7 +59318,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModePropertiesKHR, Allocator>>::type
       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
                                    Allocator const &                vectorAllocator,
-                                   Dispatch const &                 d ) const;
+                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59352,9 +59365,9 @@ namespace VULKAN_HPP_NAMESPACE
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, Allocator>>::type
-      getDisplayPlaneSupportedDisplaysKHR( uint32_t          planeIndex,
-                                           Allocator const & vectorAllocator,
-                                           Dispatch const &  d ) const;
+      getDisplayPlaneSupportedDisplaysKHR( uint32_t           planeIndex,
+                                           Allocator const &  vectorAllocator,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59372,7 +59385,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, Allocator>>::type
-      getCalibrateableTimeDomainsEXT( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getCalibrateableTimeDomainsEXT( Allocator const &  vectorAllocator,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59391,7 +59405,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
                                       int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, Allocator>>::type
-      getCooperativeMatrixPropertiesNV( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getCooperativeMatrixPropertiesNV( Allocator const &  vectorAllocator,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
@@ -59425,7 +59440,8 @@ namespace VULKAN_HPP_NAMESPACE
       typename B         = Allocator,
       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, Allocator>>::type
-      getDisplayPlaneProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getDisplayPlaneProperties2KHR( Allocator const &  vectorAllocator,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59444,7 +59460,8 @@ namespace VULKAN_HPP_NAMESPACE
       typename B         = Allocator,
       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, Allocator>>::type
-      getDisplayPlanePropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getDisplayPlanePropertiesKHR( Allocator const &  vectorAllocator,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59463,7 +59480,8 @@ namespace VULKAN_HPP_NAMESPACE
       typename B         = Allocator,
       typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayProperties2KHR, Allocator>>::type
-      getDisplayProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getDisplayProperties2KHR( Allocator const &  vectorAllocator,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59481,7 +59499,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPropertiesKHR, Allocator>>::type
-      getDisplayPropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getDisplayPropertiesKHR( Allocator const &  vectorAllocator,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59767,8 +59786,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Allocator>>::type getPresentRectanglesKHR(
-      VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Allocator const & vectorAllocator, Dispatch const & d ) const;
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Allocator>>::type
+      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                               Allocator const &                vectorAllocator,
+                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59831,8 +59852,9 @@ namespace VULKAN_HPP_NAMESPACE
       typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
       typename B         = Allocator,
       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
-    std::vector<QueueFamilyProperties, Allocator> getQueueFamilyProperties( Allocator const & vectorAllocator,
-                                                                            Dispatch const &  d ) const;
+    std::vector<QueueFamilyProperties, Allocator>
+      getQueueFamilyProperties( Allocator const &  vectorAllocator,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59850,8 +59872,9 @@ namespace VULKAN_HPP_NAMESPACE
       typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
       typename B         = Allocator,
       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
-    std::vector<QueueFamilyProperties2, Allocator> getQueueFamilyProperties2( Allocator const & vectorAllocator,
-                                                                              Dispatch const &  d ) const;
+    std::vector<QueueFamilyProperties2, Allocator>
+      getQueueFamilyProperties2( Allocator const &  vectorAllocator,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename StructureChain,
               typename Allocator = std::allocator<StructureChain>,
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59862,8 +59885,9 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
-    std::vector<StructureChain, Allocator> getQueueFamilyProperties2( Allocator const & vectorAllocator,
-                                                                      Dispatch const &  d ) const;
+    std::vector<StructureChain, Allocator>
+      getQueueFamilyProperties2( Allocator const &  vectorAllocator,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59881,8 +59905,9 @@ namespace VULKAN_HPP_NAMESPACE
       typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
       typename B         = Allocator,
       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
-    std::vector<QueueFamilyProperties2, Allocator> getQueueFamilyProperties2KHR( Allocator const & vectorAllocator,
-                                                                                 Dispatch const &  d ) const;
+    std::vector<QueueFamilyProperties2, Allocator>
+      getQueueFamilyProperties2KHR( Allocator const &  vectorAllocator,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename StructureChain,
               typename Allocator = std::allocator<StructureChain>,
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59893,8 +59918,9 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
-    std::vector<StructureChain, Allocator> getQueueFamilyProperties2KHR( Allocator const & vectorAllocator,
-                                                                         Dispatch const &  d ) const;
+    std::vector<StructureChain, Allocator>
+      getQueueFamilyProperties2KHR( Allocator const &  vectorAllocator,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59929,7 +59955,7 @@ namespace VULKAN_HPP_NAMESPACE
                                       VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
                                       VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
                                       Allocator const &                         vectorAllocator,
-                                      Dispatch const &                          d ) const;
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59952,7 +59978,7 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<SparseImageFormatProperties2, Allocator>
       getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                        Allocator const &                            vectorAllocator,
-                                       Dispatch const &                             d ) const;
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59975,7 +60001,7 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<SparseImageFormatProperties2, Allocator>
       getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                           Allocator const &                            vectorAllocator,
-                                          Dispatch const &                             d ) const;
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -59995,7 +60021,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
                                       int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, Allocator>>::type
-      getSupportedFramebufferMixedSamplesCombinationsNV( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getSupportedFramebufferMixedSamplesCombinationsNV(
+        Allocator const & vectorAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -60059,7 +60086,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, Allocator>>::type
       getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                              Allocator const &                     vectorAllocator,
-                             Dispatch const &                      d ) const;
+                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -60078,8 +60105,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, Allocator>>::type getSurfaceFormatsKHR(
-      VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Allocator const & vectorAllocator, Dispatch const & d ) const;
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, Allocator>>::type
+      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                            Allocator const &                vectorAllocator,
+                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -60102,7 +60131,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, Allocator>>::type
       getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                   Allocator const &                     vectorAllocator,
-                                  Dispatch const &                      d ) const;
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
 
@@ -60125,7 +60154,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, Allocator>>::type
       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                  Allocator const &                vectorAllocator,
-                                 Dispatch const &                 d ) const;
+                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -60158,7 +60187,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
                                       int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolPropertiesEXT, Allocator>>::type
-      getToolPropertiesEXT( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      getToolPropertiesEXT( Allocator const &  vectorAllocator,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
@@ -87334,7 +87364,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
                                       int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
-      enumeratePhysicalDeviceGroups( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      enumeratePhysicalDeviceGroups( Allocator const &  vectorAllocator,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -87353,7 +87384,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
                                       int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
-      enumeratePhysicalDeviceGroupsKHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      enumeratePhysicalDeviceGroupsKHR( Allocator const &  vectorAllocator,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -87371,7 +87403,8 @@ namespace VULKAN_HPP_NAMESPACE
               typename B         = Allocator,
               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, Allocator>>::type
-      enumeratePhysicalDevices( Allocator const & vectorAllocator, Dispatch const & d ) const;
+      enumeratePhysicalDevices( Allocator const &  vectorAllocator,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -87497,7 +87530,7 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, Allocator>>::type
     enumerateInstanceExtensionProperties( Optional<const std::string> layerName,
                                           Allocator const &           vectorAllocator,
-                                          Dispatch const &            d );
+                                          Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -87515,7 +87548,8 @@ namespace VULKAN_HPP_NAMESPACE
             typename B         = Allocator,
             typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
-    enumerateInstanceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d );
+    enumerateInstanceLayerProperties( Allocator const &  vectorAllocator,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -87753,6 +87787,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdBeginConditionalRenderingEXT(
       m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( pConditionalRenderingBegin ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -87771,6 +87806,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
@@ -87836,6 +87872,7 @@ namespace VULKAN_HPP_NAMESPACE
                             reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
                             static_cast<VkSubpassContents>( contents ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
@@ -87858,6 +87895,7 @@ namespace VULKAN_HPP_NAMESPACE
                              reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
                              reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
@@ -87880,6 +87918,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
                                 reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
@@ -88312,6 +88351,7 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VkDeviceSize>( indirectOffset ),
       indirectStride );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -88392,6 +88432,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          static_cast<VkBuffer>( scratch ),
                                          static_cast<VkDeviceSize>( scratchOffset ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -88521,6 +88562,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer,
                                          reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
@@ -88569,6 +88611,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdCopyAccelerationStructureToMemoryKHR(
       m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -88720,6 +88763,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdCopyMemoryToAccelerationStructureKHR(
       m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -88781,6 +88825,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
@@ -88811,6 +88856,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
@@ -89440,6 +89486,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo,
@@ -89455,6 +89502,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo,
@@ -89533,6 +89581,7 @@ namespace VULKAN_HPP_NAMESPACE
                                        static_cast<VkBool32>( isPreprocessed ),
                                        reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -89583,6 +89632,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
@@ -89617,6 +89667,7 @@ namespace VULKAN_HPP_NAMESPACE
                          reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
                          reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
@@ -89639,6 +89690,7 @@ namespace VULKAN_HPP_NAMESPACE
                             reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
                             reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
@@ -89707,6 +89759,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdPreprocessGeneratedCommandsNV(
       m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -90302,6 +90355,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdSetSampleLocationsEXT( m_commandBuffer,
                                   reinterpret_cast<const VkSampleLocationsInfoEXT *>( pSampleLocationsInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
@@ -90564,6 +90618,7 @@ namespace VULKAN_HPP_NAMESPACE
                                  static_cast<VkBuffer>( buffer ),
                                  static_cast<VkDeviceSize>( offset ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedBufferRegionKHR & raygenShaderBindingTable,
@@ -90606,6 +90661,7 @@ namespace VULKAN_HPP_NAMESPACE
                          height,
                          depth );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedBufferRegionKHR & raygenShaderBindingTable,
@@ -94151,6 +94207,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -94158,10 +94215,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Optional<const AllocationCallbacks>            allocator,
                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyAccelerationStructureKHR(
-      m_device,
-      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyAccelerationStructureKHR( m_device,
+                                         static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -94176,6 +94232,7 @@ namespace VULKAN_HPP_NAMESPACE
                                         static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -94183,10 +94240,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Optional<const AllocationCallbacks>            allocator,
                                             Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyAccelerationStructureNV(
-      m_device,
-      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyAccelerationStructureNV( m_device,
+                                        static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94205,6 +94261,7 @@ namespace VULKAN_HPP_NAMESPACE
                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
@@ -94212,15 +94269,13 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
 #  ifdef VK_ENABLE_BETA_EXTENSIONS
-    d.vkDestroyAccelerationStructureKHR(
-      m_device,
-      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyAccelerationStructureKHR( m_device,
+                                         static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
 #  else
-    d.vkDestroyAccelerationStructureNV(
-      m_device,
-      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyAccelerationStructureNV( m_device,
+                                        static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -94233,6 +94288,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyBuffer(
       m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer        buffer,
@@ -94240,9 +94296,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyBuffer(
-      m_device,
-      static_cast<VkBuffer>( buffer ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94254,6 +94308,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyBuffer(
       m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer        buffer,
@@ -94261,9 +94316,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyBuffer(
-      m_device,
-      static_cast<VkBuffer>( buffer ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94276,16 +94329,16 @@ namespace VULKAN_HPP_NAMESPACE
                            static_cast<VkBufferView>( bufferView ),
                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView    bufferView,
                                                     Optional<const AllocationCallbacks> allocator,
                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyBufferView(
-      m_device,
-      static_cast<VkBufferView>( bufferView ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyBufferView( m_device,
+                           static_cast<VkBufferView>( bufferView ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94298,16 +94351,16 @@ namespace VULKAN_HPP_NAMESPACE
                            static_cast<VkBufferView>( bufferView ),
                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView    bufferView,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyBufferView(
-      m_device,
-      static_cast<VkBufferView>( bufferView ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyBufferView( m_device,
+                           static_cast<VkBufferView>( bufferView ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94320,16 +94373,16 @@ namespace VULKAN_HPP_NAMESPACE
                             static_cast<VkCommandPool>( commandPool ),
                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool   commandPool,
                                                      Optional<const AllocationCallbacks> allocator,
                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyCommandPool(
-      m_device,
-      static_cast<VkCommandPool>( commandPool ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyCommandPool( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94342,16 +94395,16 @@ namespace VULKAN_HPP_NAMESPACE
                             static_cast<VkCommandPool>( commandPool ),
                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool   commandPool,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyCommandPool(
-      m_device,
-      static_cast<VkCommandPool>( commandPool ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyCommandPool( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94366,16 +94419,16 @@ namespace VULKAN_HPP_NAMESPACE
                                      static_cast<VkDeferredOperationKHR>( operation ),
                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
                                                               Optional<const AllocationCallbacks>        allocator,
                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDeferredOperationKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( operation ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDeferredOperationKHR( m_device,
+                                     static_cast<VkDeferredOperationKHR>( operation ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -94390,16 +94443,16 @@ namespace VULKAN_HPP_NAMESPACE
                                      static_cast<VkDeferredOperationKHR>( operation ),
                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
                                           Optional<const AllocationCallbacks>        allocator,
                                           Dispatch const &                           d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDeferredOperationKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( operation ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDeferredOperationKHR( m_device,
+                                     static_cast<VkDeferredOperationKHR>( operation ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -94413,16 +94466,16 @@ namespace VULKAN_HPP_NAMESPACE
                                static_cast<VkDescriptorPool>( descriptorPool ),
                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
                                                         Optional<const AllocationCallbacks>  allocator,
                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDescriptorPool(
-      m_device,
-      static_cast<VkDescriptorPool>( descriptorPool ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDescriptorPool( m_device,
+                               static_cast<VkDescriptorPool>( descriptorPool ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94435,16 +94488,16 @@ namespace VULKAN_HPP_NAMESPACE
                                static_cast<VkDescriptorPool>( descriptorPool ),
                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
                                           Optional<const AllocationCallbacks>  allocator,
                                           Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDescriptorPool(
-      m_device,
-      static_cast<VkDescriptorPool>( descriptorPool ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDescriptorPool( m_device,
+                               static_cast<VkDescriptorPool>( descriptorPool ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94458,6 +94511,7 @@ namespace VULKAN_HPP_NAMESPACE
                                     static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -94465,10 +94519,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Optional<const AllocationCallbacks>       allocator,
                                         Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDescriptorSetLayout(
-      m_device,
-      static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDescriptorSetLayout( m_device,
+                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94481,16 +94534,16 @@ namespace VULKAN_HPP_NAMESPACE
                                     static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
                                           Optional<const AllocationCallbacks>       allocator,
                                           Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDescriptorSetLayout(
-      m_device,
-      static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDescriptorSetLayout( m_device,
+                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94504,6 +94557,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -94511,10 +94565,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Optional<const AllocationCallbacks>            allocator,
                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDescriptorUpdateTemplate(
-      m_device,
-      static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDescriptorUpdateTemplate( m_device,
+                                         static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94528,6 +94581,7 @@ namespace VULKAN_HPP_NAMESPACE
                                             static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
                                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -94535,10 +94589,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Optional<const AllocationCallbacks>            allocator,
                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDescriptorUpdateTemplateKHR(
-      m_device,
-      static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDescriptorUpdateTemplateKHR( m_device,
+                                            static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+                                            reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94551,16 +94604,16 @@ namespace VULKAN_HPP_NAMESPACE
                                          static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
                                           Optional<const AllocationCallbacks>            allocator,
                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDescriptorUpdateTemplate(
-      m_device,
-      static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDescriptorUpdateTemplate( m_device,
+                                         static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94570,14 +94623,13 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDevice(
-      m_device,
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94589,6 +94641,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyEvent(
       m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event         event,
@@ -94596,9 +94649,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyEvent(
-      m_device,
-      static_cast<VkEvent>( event ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94610,6 +94661,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyEvent(
       m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event         event,
@@ -94617,9 +94669,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyEvent(
-      m_device,
-      static_cast<VkEvent>( event ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94631,6 +94681,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyFence(
       m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence         fence,
@@ -94638,9 +94689,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyFence(
-      m_device,
-      static_cast<VkFence>( fence ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94652,6 +94701,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyFence(
       m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence         fence,
@@ -94659,9 +94709,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyFence(
-      m_device,
-      static_cast<VkFence>( fence ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94674,16 +94722,16 @@ namespace VULKAN_HPP_NAMESPACE
                             static_cast<VkFramebuffer>( framebuffer ),
                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer   framebuffer,
                                                      Optional<const AllocationCallbacks> allocator,
                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyFramebuffer(
-      m_device,
-      static_cast<VkFramebuffer>( framebuffer ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyFramebuffer( m_device,
+                            static_cast<VkFramebuffer>( framebuffer ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94696,16 +94744,16 @@ namespace VULKAN_HPP_NAMESPACE
                             static_cast<VkFramebuffer>( framebuffer ),
                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer   framebuffer,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyFramebuffer(
-      m_device,
-      static_cast<VkFramebuffer>( framebuffer ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyFramebuffer( m_device,
+                            static_cast<VkFramebuffer>( framebuffer ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94717,6 +94765,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyImage(
       m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image         image,
@@ -94724,9 +94773,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyImage(
-      m_device,
-      static_cast<VkImage>( image ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94738,6 +94785,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyImage(
       m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image         image,
@@ -94745,9 +94793,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyImage(
-      m_device,
-      static_cast<VkImage>( image ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94759,6 +94805,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyImageView(
       m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView     imageView,
@@ -94766,9 +94813,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyImageView(
-      m_device,
-      static_cast<VkImageView>( imageView ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94780,6 +94825,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyImageView(
       m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView     imageView,
@@ -94787,9 +94833,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyImageView(
-      m_device,
-      static_cast<VkImageView>( imageView ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94803,6 +94847,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -94810,10 +94855,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Optional<const AllocationCallbacks>            allocator,
                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyIndirectCommandsLayoutNV(
-      m_device,
-      static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyIndirectCommandsLayoutNV( m_device,
+                                         static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94826,16 +94870,16 @@ namespace VULKAN_HPP_NAMESPACE
                                          static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
                                           Optional<const AllocationCallbacks>            allocator,
                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyIndirectCommandsLayoutNV(
-      m_device,
-      static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyIndirectCommandsLayoutNV( m_device,
+                                         static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94847,6 +94891,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyPipeline(
       m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline      pipeline,
@@ -94854,9 +94899,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyPipeline(
-      m_device,
-      static_cast<VkPipeline>( pipeline ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94868,6 +94911,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyPipeline(
       m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline      pipeline,
@@ -94875,9 +94919,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyPipeline(
-      m_device,
-      static_cast<VkPipeline>( pipeline ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94890,16 +94932,16 @@ namespace VULKAN_HPP_NAMESPACE
                               static_cast<VkPipelineCache>( pipelineCache ),
                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
                                                        Optional<const AllocationCallbacks> allocator,
                                                        Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyPipelineCache(
-      m_device,
-      static_cast<VkPipelineCache>( pipelineCache ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyPipelineCache( m_device,
+                              static_cast<VkPipelineCache>( pipelineCache ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94912,16 +94954,16 @@ namespace VULKAN_HPP_NAMESPACE
                               static_cast<VkPipelineCache>( pipelineCache ),
                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyPipelineCache(
-      m_device,
-      static_cast<VkPipelineCache>( pipelineCache ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyPipelineCache( m_device,
+                              static_cast<VkPipelineCache>( pipelineCache ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94934,16 +94976,16 @@ namespace VULKAN_HPP_NAMESPACE
                                static_cast<VkPipelineLayout>( pipelineLayout ),
                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
                                                         Optional<const AllocationCallbacks>  allocator,
                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyPipelineLayout(
-      m_device,
-      static_cast<VkPipelineLayout>( pipelineLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyPipelineLayout( m_device,
+                               static_cast<VkPipelineLayout>( pipelineLayout ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94956,16 +94998,16 @@ namespace VULKAN_HPP_NAMESPACE
                                static_cast<VkPipelineLayout>( pipelineLayout ),
                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
                                           Optional<const AllocationCallbacks>  allocator,
                                           Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyPipelineLayout(
-      m_device,
-      static_cast<VkPipelineLayout>( pipelineLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyPipelineLayout( m_device,
+                               static_cast<VkPipelineLayout>( pipelineLayout ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -94979,16 +95021,16 @@ namespace VULKAN_HPP_NAMESPACE
                                    static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
                                                             Optional<const AllocationCallbacks>      allocator,
                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyPrivateDataSlotEXT(
-      m_device,
-      static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyPrivateDataSlotEXT( m_device,
+                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95001,16 +95043,16 @@ namespace VULKAN_HPP_NAMESPACE
                                    static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
                                           Optional<const AllocationCallbacks>      allocator,
                                           Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyPrivateDataSlotEXT(
-      m_device,
-      static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyPrivateDataSlotEXT( m_device,
+                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95022,6 +95064,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyQueryPool(
       m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool     queryPool,
@@ -95029,9 +95072,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyQueryPool(
-      m_device,
-      static_cast<VkQueryPool>( queryPool ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95043,6 +95084,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroyQueryPool(
       m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool     queryPool,
@@ -95050,9 +95092,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroyQueryPool(
-      m_device,
-      static_cast<VkQueryPool>( queryPool ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95065,16 +95105,16 @@ namespace VULKAN_HPP_NAMESPACE
                            static_cast<VkRenderPass>( renderPass ),
                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass    renderPass,
                                                     Optional<const AllocationCallbacks> allocator,
                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyRenderPass(
-      m_device,
-      static_cast<VkRenderPass>( renderPass ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyRenderPass( m_device,
+                           static_cast<VkRenderPass>( renderPass ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95087,16 +95127,16 @@ namespace VULKAN_HPP_NAMESPACE
                            static_cast<VkRenderPass>( renderPass ),
                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass    renderPass,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyRenderPass(
-      m_device,
-      static_cast<VkRenderPass>( renderPass ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyRenderPass( m_device,
+                           static_cast<VkRenderPass>( renderPass ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95108,6 +95148,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroySampler(
       m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler       sampler,
@@ -95115,9 +95156,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroySampler(
-      m_device,
-      static_cast<VkSampler>( sampler ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95129,6 +95168,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroySampler(
       m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler       sampler,
@@ -95136,9 +95176,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroySampler(
-      m_device,
-      static_cast<VkSampler>( sampler ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95152,6 +95190,7 @@ namespace VULKAN_HPP_NAMESPACE
                                        static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -95159,10 +95198,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Optional<const AllocationCallbacks>          allocator,
                                            Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroySamplerYcbcrConversion(
-      m_device,
-      static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroySamplerYcbcrConversion( m_device,
+                                       static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95176,6 +95214,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
                                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -95183,10 +95222,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Optional<const AllocationCallbacks>          allocator,
                                               Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroySamplerYcbcrConversionKHR(
-      m_device,
-      static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroySamplerYcbcrConversionKHR( m_device,
+                                          static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
+                                          reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95199,16 +95237,16 @@ namespace VULKAN_HPP_NAMESPACE
                                        static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
                                           Optional<const AllocationCallbacks>          allocator,
                                           Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroySamplerYcbcrConversion(
-      m_device,
-      static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroySamplerYcbcrConversion( m_device,
+                                       static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95220,6 +95258,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroySemaphore(
       m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore     semaphore,
@@ -95227,9 +95266,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroySemaphore(
-      m_device,
-      static_cast<VkSemaphore>( semaphore ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95241,6 +95278,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroySemaphore(
       m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore     semaphore,
@@ -95248,9 +95286,7 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroySemaphore(
-      m_device,
-      static_cast<VkSemaphore>( semaphore ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95263,16 +95299,16 @@ namespace VULKAN_HPP_NAMESPACE
                              static_cast<VkShaderModule>( shaderModule ),
                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule  shaderModule,
                                                       Optional<const AllocationCallbacks> allocator,
                                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyShaderModule(
-      m_device,
-      static_cast<VkShaderModule>( shaderModule ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyShaderModule( m_device,
+                             static_cast<VkShaderModule>( shaderModule ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95285,16 +95321,16 @@ namespace VULKAN_HPP_NAMESPACE
                              static_cast<VkShaderModule>( shaderModule ),
                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule  shaderModule,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyShaderModule(
-      m_device,
-      static_cast<VkShaderModule>( shaderModule ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyShaderModule( m_device,
+                             static_cast<VkShaderModule>( shaderModule ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95307,16 +95343,16 @@ namespace VULKAN_HPP_NAMESPACE
                              static_cast<VkSwapchainKHR>( swapchain ),
                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR  swapchain,
                                                       Optional<const AllocationCallbacks> allocator,
                                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroySwapchainKHR(
-      m_device,
-      static_cast<VkSwapchainKHR>( swapchain ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroySwapchainKHR( m_device,
+                             static_cast<VkSwapchainKHR>( swapchain ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95329,16 +95365,16 @@ namespace VULKAN_HPP_NAMESPACE
                              static_cast<VkSwapchainKHR>( swapchain ),
                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR  swapchain,
                                           Optional<const AllocationCallbacks> allocator,
                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroySwapchainKHR(
-      m_device,
-      static_cast<VkSwapchainKHR>( swapchain ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroySwapchainKHR( m_device,
+                             static_cast<VkSwapchainKHR>( swapchain ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95352,16 +95388,16 @@ namespace VULKAN_HPP_NAMESPACE
                                    static_cast<VkValidationCacheEXT>( validationCache ),
                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
                                                             Optional<const AllocationCallbacks>      allocator,
                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyValidationCacheEXT(
-      m_device,
-      static_cast<VkValidationCacheEXT>( validationCache ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyValidationCacheEXT( m_device,
+                                   static_cast<VkValidationCacheEXT>( validationCache ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95374,16 +95410,16 @@ namespace VULKAN_HPP_NAMESPACE
                                    static_cast<VkValidationCacheEXT>( validationCache ),
                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
                                           Optional<const AllocationCallbacks>      allocator,
                                           Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyValidationCacheEXT(
-      m_device,
-      static_cast<VkValidationCacheEXT>( validationCache ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyValidationCacheEXT( m_device,
+                                   static_cast<VkValidationCacheEXT>( validationCache ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95562,6 +95598,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkFreeMemory(
       m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory  memory,
@@ -95569,9 +95606,7 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkFreeMemory(
-      m_device,
-      static_cast<VkDeviceMemory>( memory ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -95583,6 +95618,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkFreeMemory(
       m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::DeviceMemory  memory,
@@ -95590,9 +95626,7 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkFreeMemory(
-      m_device,
-      static_cast<VkDeviceMemory>( memory ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100147,16 +100181,16 @@ namespace VULKAN_HPP_NAMESPACE
                                        static_cast<VkDebugReportCallbackEXT>( callback ),
                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
                                                                   Optional<const AllocationCallbacks> allocator,
                                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDebugReportCallbackEXT(
-      m_instance,
-      static_cast<VkDebugReportCallbackEXT>( callback ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDebugReportCallbackEXT( m_instance,
+                                       static_cast<VkDebugReportCallbackEXT>( callback ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100169,16 +100203,16 @@ namespace VULKAN_HPP_NAMESPACE
                                        static_cast<VkDebugReportCallbackEXT>( callback ),
                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
                                             Optional<const AllocationCallbacks>          allocator,
                                             Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDebugReportCallbackEXT(
-      m_instance,
-      static_cast<VkDebugReportCallbackEXT>( callback ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDebugReportCallbackEXT( m_instance,
+                                       static_cast<VkDebugReportCallbackEXT>( callback ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100192,6 +100226,7 @@ namespace VULKAN_HPP_NAMESPACE
                                        static_cast<VkDebugUtilsMessengerEXT>( messenger ),
                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -100199,10 +100234,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Optional<const AllocationCallbacks>          allocator,
                                              Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDebugUtilsMessengerEXT(
-      m_instance,
-      static_cast<VkDebugUtilsMessengerEXT>( messenger ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance,
+                                       static_cast<VkDebugUtilsMessengerEXT>( messenger ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100215,16 +100249,16 @@ namespace VULKAN_HPP_NAMESPACE
                                        static_cast<VkDebugUtilsMessengerEXT>( messenger ),
                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
                                             Optional<const AllocationCallbacks>          allocator,
                                             Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyDebugUtilsMessengerEXT(
-      m_instance,
-      static_cast<VkDebugUtilsMessengerEXT>( messenger ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance,
+                                       static_cast<VkDebugUtilsMessengerEXT>( messenger ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100234,14 +100268,13 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator,
                                             Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkDestroyInstance(
-      m_instance,
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+    d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100253,6 +100286,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroySurfaceKHR(
       m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR    surface,
@@ -100260,9 +100294,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroySurfaceKHR(
-      m_instance,
-      static_cast<VkSurfaceKHR>( surface ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100274,6 +100306,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkDestroySurfaceKHR(
       m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR    surface,
@@ -100281,9 +100314,7 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkDestroySurfaceKHR(
-      m_instance,
-      static_cast<VkSurfaceKHR>( surface ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+      m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( &allocator ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -100533,6 +100564,7 @@ namespace VULKAN_HPP_NAMESPACE
                                     static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
                                     reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( pCallbackData ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -103720,6 +103752,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
@@ -103777,6 +103810,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,