diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index bbb3f23..4a8ba4c 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -2254,26 +2254,21 @@ std::string VulkanHppGenerator::generateCallArgumentsEnhanced( CommandData const
         encounteredArgument = true;
         break;
       case 2:
-        assert( isHandleType( commandData.params[0].type.type ) && commandData.params[0].type.isValue() );
-        assert( commandData.params[0].arraySizes.empty() && commandData.params[0].len.empty() );
-        assert( commandData.params[0].type.type == commandData.handle );
-        if ( skipLeadingGrandParent( *m_handles.find( commandData.params[1].type.type ) ) )
         {
-          auto [parentType, parentName] = getParentTypeAndName( *m_handles.find( commandData.params[1].type.type ) );
-          arguments                     = "static_cast<" + commandData.handle + ">( **m_" + parentName + "->get" +
-                      stripPrefix( commandData.handle, "Vk" ) + "() )";
-        }
-        else
-        {
-          arguments = "static_cast<" + commandData.handle + ">( **m_" +
+          assert( isHandleType( commandData.params[0].type.type ) && commandData.params[0].type.isValue() );
+          assert( commandData.params[0].arraySizes.empty() && commandData.params[0].len.empty() );
+          assert( commandData.params[0].type.type == commandData.handle );
+          auto handleIt = m_handles.find( commandData.params[1].type.type );
+          assert( handleIt != m_handles.end() );
+          arguments = "static_cast<" + commandData.handle + ">( m_" +
                       startLowerCase( stripPrefix( commandData.handle, "Vk" ) ) + " )";
-        }
 
-        assert( isHandleType( commandData.params[1].type.type ) && commandData.params[1].type.isValue() );
-        assert( commandData.params[1].arraySizes.empty() && commandData.params[1].len.empty() );
-        arguments += ", static_cast<" + commandData.params[1].type.type + ">( m_" +
-                     startLowerCase( stripPrefix( commandData.params[1].type.type, "Vk" ) ) + " )";
-        encounteredArgument = true;
+          assert( commandData.params[1].type.isValue() && commandData.params[1].arraySizes.empty() &&
+                  commandData.params[1].len.empty() );
+          arguments += ", static_cast<" + commandData.params[1].type.type + ">( m_" +
+                       generateRAIIHandleConstructorParamName( handleIt->first, handleIt->second.destructorIt ) + " )";
+          encounteredArgument = true;
+        }
         break;
     }
   }
@@ -7169,16 +7164,15 @@ std::string VulkanHppGenerator::generateRAIIHandle( std::pair<std::string, Handl
   {
     rescheduleRAIIHandle( str, handle, listedHandles, specialFunctions );
 
-    auto [enter, leave]           = generateProtection( handle.first, !handle.second.alias.empty() );
-    std::string handleType        = stripPrefix( handle.first, "Vk" );
-    std::string handleName        = startLowerCase( handleType );
-    auto [parentType, parentName] = getParentTypeAndName( handle );
+    auto [enter, leave]    = generateProtection( handle.first, !handle.second.alias.empty() );
+    std::string handleType = stripPrefix( handle.first, "Vk" );
+    std::string handleName = generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt );
 
     auto [singularConstructors, arrayConstructors] = generateRAIIHandleConstructors( handle );
     auto [destructor, destructorCall] =
       ( handle.second.destructorIt == m_commands.end() )
         ? std::make_pair( "", "" )
-        : generateRAIIHandleDestructor( "Vk" + parentType, handle.first, handle.second.destructorIt, enter );
+        : generateRAIIHandleDestructor( handle.first, handle.second.destructorIt, enter );
 
     auto [getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions] =
       generateRAIIHandleDetails( handle, destructorCall );
@@ -7212,6 +7206,18 @@ std::string VulkanHppGenerator::generateRAIIHandle( std::pair<std::string, Handl
         ? "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher"
         : "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher";
 
+    std::string getParent;
+    if ( ( handle.first != "VkInstance" ) && ( handle.first != "VkDevice" ) &&
+         ( handle.second.destructorIt != m_commands.end() ) )
+    {
+      assert( !handle.second.destructorIt->second.params.empty() );
+      std::string parentType = stripPrefix( handle.second.destructorIt->second.params.front().type.type, "Vk" );
+      getParent              = "    VULKAN_HPP_NAMESPACE::" + parentType + " get" + parentType + "() const\n";
+      getParent += "    {\n";
+      getParent += "      return m_" + handle.second.destructorIt->second.params.front().name + ";\n";
+      getParent += "    }\n";
+    }
+
     const std::string handleTemplate = R"(
 ${enter}  class ${handleType}
   {
@@ -7247,11 +7253,7 @@ ${moveAssignmentInstructions}
     }
 
 ${getConstructorSuccessCode}
-    VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::${parentType} const * get${parentType}() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_${parentName};
-    }
-
+${getParent}
     ${dispatcherType} const * getDispatcher() const
     {
       VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -7272,6 +7274,7 @@ ${leave})";
         { "enter", enter },
         { "getConstructorSuccessCode", getConstructorSuccessCode },
         { "getDispatcherReturn", ( handleType == "Device" ) || ( handleType == "Instance" ) ? "&*" : "" },
+        { "getParent", getParent },
         { "handleName", handleName },
         { "handleType", handleType },
         { "leave", leave },
@@ -7280,8 +7283,6 @@ ${leave})";
         { "moveAssignmentInstructions", moveAssignmentInstructions },
         { "moveConstructorInitializerList", moveConstructorInitializerList },
         { "objTypeEnum", objTypeEnum },
-        { "parentType", parentType },
-        { "parentName", parentName },
         { "singularConstructors", singularConstructors } } );
 
     if ( !arrayConstructors.empty() )
@@ -9628,7 +9629,8 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorArguments(
   std::string arguments = "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::" + parentType + " const & " + parentName;
   if ( takesOwnership )
   {
-    arguments += ", " + handle.first + " " + startLowerCase( stripPrefix( handle.first, "Vk" ) );
+    arguments +=
+      ", " + handle.first + " " + generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt );
   }
 
   if ( constructorIt != m_commands.end() )
@@ -9688,7 +9690,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments(
     assert( ( 1 < constructorIt->second.params.size() ) &&
             ( m_handles.find( constructorIt->second.params[0].type.type ) != m_handles.end() ) &&
             ( m_handles.find( constructorIt->second.params[1].type.type ) != m_handles.end() ) );
-    arguments += "static_cast<" + constructorIt->second.params[0].type.type + ">( **" +
+    arguments += "static_cast<" + constructorIt->second.params[0].type.type + ">( " +
                  constructorIt->second.params[1].name + ".get" +
                  stripPrefix( constructorIt->second.params[0].type.type, "Vk" ) + "() )";
     encounteredArgument = true;
@@ -9708,8 +9710,8 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments(
       {
         assert( !param.optional );
         assert( singularParams.empty() || ( param.len == constructorIt->second.params[*singularParams.begin()].name ) );
-        arguments +=
-          "reinterpret_cast<" + handle.first + "*>( &m_" + startLowerCase( stripPrefix( handle.first, "Vk" ) ) + " )";
+        std::string paramName = generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt );
+        arguments += "reinterpret_cast<" + handle.first + "*>( &m_" + paramName + " )";
       }
       else if ( nonConstPointerAsNullptr )
       {
@@ -9725,8 +9727,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments(
       assert( param.optional );
       if ( allocatorIsMemberVariable )
       {
-        // VkAllocationCallbacks is stored as a member of the handle class !
-        arguments += "m_allocator";
+        arguments += "reinterpret_cast<const VkAllocationCallbacks *>( m_allocator )";
       }
       else
       {
@@ -9830,81 +9831,140 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorInitializationList(
   bool                                                                   takesOwnership ) const
 {
   auto [parentType, parentName] = getParentTypeAndName( handle );
-  std::string handleName        = startLowerCase( stripPrefix( handle.first, "Vk" ) );
-
-  std::string initializationList = "m_" + parentName + "( &" + parentName + " )";
-  if ( takesOwnership )
-  {
-    initializationList += ", m_" + handleName + "( " + handleName + " )";
-  }
+  std::string handleName        = generateRAIIHandleConstructorParamName( handle.first, destructorIt );
 
+  std::string initializationList;
   if ( destructorIt != m_commands.end() )
   {
     for ( auto destructorParam : destructorIt->second.params )
     {
-      if ( ( destructorParam.type.type != ( "Vk" + parentType ) ) && ( destructorParam.type.type != handle.first ) )
+      if ( destructorParam.type.type == "Vk" + parentType )
       {
-        if ( isHandleType( destructorParam.type.type ) )
+        initializationList += "m_" + parentName + "( *" + parentName + " ), ";
+      }
+      else if ( destructorParam.type.type == handle.first )
+      {
+        if ( takesOwnership )
         {
-          assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() &&
-                  !destructorParam.optional );
-          initializationList += ", m_" + startLowerCase( stripPrefix( destructorParam.type.type, "Vk" ) ) + "( ";
-          auto constructorParamIt = std::find_if( constructorIt->second.params.begin(),
-                                                  constructorIt->second.params.end(),
-                                                  [&destructorParam]( ParamData const & pd )
-                                                  { return pd.type.type == destructorParam.type.type; } );
-          if ( constructorParamIt != constructorIt->second.params.end() )
-          {
-            assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() &&
-                    constructorParamIt->len.empty() && !constructorParamIt->optional );
-            initializationList += constructorParamIt->name;
-          }
-          else
-          {
-#if !defined( NDEBUG )
-            bool found = false;
-#endif
-            for ( auto constructorParam : constructorIt->second.params )
-            {
-              auto structureIt = m_structures.find( constructorParam.type.type );
-              if ( structureIt != m_structures.end() )
-              {
-                auto structureMemberIt = std::find_if( structureIt->second.members.begin(),
-                                                       structureIt->second.members.end(),
-                                                       [&destructorParam]( MemberData const & md )
-                                                       { return md.type.type == destructorParam.type.type; } );
-                if ( structureMemberIt != structureIt->second.members.end() )
-                {
-                  assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() &&
-                          constructorParam.len.empty() && !constructorParam.optional );
-                  initializationList +=
-                    startLowerCase( stripPrefix( constructorParam.name, "p" ) ) + "." + structureMemberIt->name;
-#if !defined( NDEBUG )
-                  found = true;
-#endif
-                  break;
-                }
-              }
-            }
-            assert( found );
-          }
-          initializationList += " )";
+          initializationList += "m_" + handleName + "( " + handleName + " ), ";
         }
-        else if ( destructorParam.type.type == "VkAllocationCallbacks" )
+      }
+      else if ( destructorParam.type.type == "VkAllocationCallbacks" )
+      {
+        assert( destructorParam.type.isConstPointer() && destructorParam.arraySizes.empty() &&
+                destructorParam.len.empty() && destructorParam.optional );
+        initializationList +=
+          "m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), ";
+      }
+      else if ( isHandleType( destructorParam.type.type ) )
+      {
+        assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() &&
+                !destructorParam.optional );
+        initializationList += "m_" + destructorParam.name + "( ";
+        auto constructorParamIt = std::find_if( constructorIt->second.params.begin(),
+                                                constructorIt->second.params.end(),
+                                                [&destructorParam]( ParamData const & pd )
+                                                { return pd.type.type == destructorParam.type.type; } );
+        if ( constructorParamIt != constructorIt->second.params.end() )
         {
-          assert( destructorParam.type.isConstPointer() && destructorParam.arraySizes.empty() &&
-                  destructorParam.len.empty() && destructorParam.optional );
-          initializationList +=
-            ", m_allocator( reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )";
+          assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() &&
+                  constructorParamIt->len.empty() && !constructorParamIt->optional );
+          if ( constructorParamIt->type.type == "Vk" + parentType )
+          {
+            initializationList += "*";
+          }
+          initializationList += constructorParamIt->name;
         }
         else
         {
-          // we can ignore all other parameters here !
+#if !defined( NDEBUG )
+          bool found = false;
+#endif
+          for ( auto constructorParam : constructorIt->second.params )
+          {
+            auto structureIt = m_structures.find( constructorParam.type.type );
+            if ( structureIt != m_structures.end() )
+            {
+              auto structureMemberIt = std::find_if( structureIt->second.members.begin(),
+                                                     structureIt->second.members.end(),
+                                                     [&destructorParam]( MemberData const & md )
+                                                     { return md.type.type == destructorParam.type.type; } );
+              if ( structureMemberIt != structureIt->second.members.end() )
+              {
+                assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() &&
+                        constructorParam.len.empty() && !constructorParam.optional );
+                initializationList +=
+                  startLowerCase( stripPrefix( constructorParam.name, "p" ) ) + "." + structureMemberIt->name;
+#if !defined( NDEBUG )
+                found = true;
+#endif
+                break;
+              }
+            }
+          }
+          assert( found );
         }
+        initializationList += " ), ";
+      }
+      else
+      {
+        // we can ignore all other parameters here !
       }
     }
   }
-  return initializationList;
+  else
+  {
+    if ( !handle.second.secondLevelCommands.empty() )
+    {
+      assert( !handle.second.constructorIts.empty() );
+      auto constructorCommandIt = m_commands.find( handle.second.constructorIts.front()->first );
+      assert( ( constructorCommandIt != m_commands.end() ) && ( 1 < constructorCommandIt->second.params.size() ) );
+      assert( std::next( constructorCommandIt->second.params.begin() )->type.type == "Vk" + parentType );
+
+      auto commandIt = m_commands.find( *handle.second.secondLevelCommands.begin() );
+      assert( ( commandIt != m_commands.end() ) && ( 1 < commandIt->second.params.size() ) );
+      assert( commandIt->second.params.front().type.type == constructorCommandIt->second.params.front().type.type );
+      assert( std::next( commandIt->second.params.begin() )->type.type == handle.first );
+
+      std::string grandParentType = stripPrefix( commandIt->second.params.front().type.type, "Vk" );
+      initializationList +=
+        "m_" + startLowerCase( grandParentType ) + "( " + parentName + ".get" + grandParentType + "() ), ";
+    }
+    if ( takesOwnership )
+    {
+      initializationList += "m_" + handleName + "( " + handleName + " ), ";
+    }
+  }
+  return initializationList.empty() ? initializationList
+                                    : initializationList.substr( 0, initializationList.size() - 2 );
+}
+
+std::string VulkanHppGenerator::generateRAIIHandleConstructorParamName(
+  std::string const & type, std::map<std::string, CommandData>::const_iterator destructorIt ) const
+{
+  if ( destructorIt != m_commands.end() )
+  {
+    auto destructorParamIt =
+      std::find_if( destructorIt->second.params.begin(),
+                    destructorIt->second.params.end(),
+                    [&type]( ParamData const & destructorParam ) { return destructorParam.type.type == type; } );
+    if ( destructorParamIt != destructorIt->second.params.end() )
+    {
+      assert( std::find_if( std::next( destructorParamIt ),
+                            destructorIt->second.params.end(),
+                            [&type]( ParamData const & destructorParam )
+                            { return destructorParam.type.type == type; } ) == destructorIt->second.params.end() );
+      if ( !destructorParamIt->type.isValue() )
+      {
+        return startLowerCase( stripPrefix( stripPluralS( destructorParamIt->name ), "p" ) );
+      }
+      else
+      {
+        return destructorParamIt->name;
+      }
+    }
+  }
+  return startLowerCase( stripPrefix( type, "Vk" ) );
 }
 
 std::string VulkanHppGenerator::generateRAIIHandleConstructorResult(
@@ -9919,7 +9979,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult(
   std::string dispatcherInitializer, dispatcherInit;
   if ( ( handle.first != "VkInstance" ) && ( handle.first != "VkDevice" ) )
   {
-    dispatcherInitializer = ", m_dispatcher( " + getDispatcher + " )";
+    dispatcherInitializer = "m_dispatcher( " + getDispatcher + " )";
   }
   else
   {
@@ -9937,6 +9997,10 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult(
 
   std::string initializationList =
     generateRAIIHandleConstructorInitializationList( handle, constructorIt, handle.second.destructorIt, false );
+  if ( !initializationList.empty() && !dispatcherInitializer.empty() )
+  {
+    initializationList += ", ";
+  }
 
   const std::string constructorTemplate =
     R"(
@@ -9973,12 +10037,6 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorTakeOwnership(
 
   auto [parentType, parentName] = getParentTypeAndName( handle );
 
-  std::string dispatcherInitializer;
-  if ( ( handle.first != "VkInstance" ) && ( handle.first != "VkDevice" ) )
-  {
-    dispatcherInitializer = ", m_dispatcher( " + parentName + ".getDispatcher() )";
-  }
-
   std::string constructorArguments =
     generateRAIIHandleConstructorArguments( handle, handle.second.destructorIt, false, true );
   std::string initializationList = generateRAIIHandleConstructorInitializationList(
@@ -9997,6 +10055,16 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorTakeOwnership(
     initializationList += ", m_constructorSuccessCode( successCode )";
   }
 
+  std::string dispatcherInitializer;
+  if ( ( handle.first != "VkInstance" ) && ( handle.first != "VkDevice" ) )
+  {
+    dispatcherInitializer = "m_dispatcher( " + parentName + ".getDispatcher() )";
+  }
+  if ( !initializationList.empty() && !dispatcherInitializer.empty() )
+  {
+    initializationList += ", ";
+  }
+
   std::string dispatcherInit;
   if ( ( handle.first == "VkDevice" ) || ( handle.first == "VkInstance" ) )
   {
@@ -10160,12 +10228,15 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorVoid(
   std::string constructorArguments = generateRAIIHandleConstructorArguments( handle, constructorIt, false, false );
   std::string initializationList =
     generateRAIIHandleConstructorInitializationList( handle, constructorIt, handle.second.destructorIt, false );
-  assert( !initializationList.empty() );
+  if ( !initializationList.empty() )
+  {
+    initializationList += ", ";
+  }
 
   const std::string constructorTemplate =
     R"(
 ${enter}    ${handleType}( ${constructorArguments} )
-      : ${initializationList}, m_dispatcher( ${firstArgument}.getDispatcher() )
+      : ${initializationList}m_dispatcher( ${firstArgument}.getDispatcher() )
     {
       getDispatcher()->${constructorCall}( ${callArguments} );
     }
@@ -10190,7 +10261,8 @@ std::string VulkanHppGenerator::generateRAIIHandleContext( std::pair<std::string
     {
     public:
       Context()
-        : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) ) )
+        : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher(
+            m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) ) )
       {}
 
       ~Context() = default;
@@ -10232,8 +10304,7 @@ ${memberFunctionDeclarations}
 }
 
 std::pair<std::string, std::string>
-  VulkanHppGenerator::generateRAIIHandleDestructor( std::string const &                                parentType,
-                                                    std::string const &                                handleType,
+  VulkanHppGenerator::generateRAIIHandleDestructor( std::string const &                                handleType,
                                                     std::map<std::string, CommandData>::const_iterator destructorIt,
                                                     std::string const &                                enter ) const
 {
@@ -10245,8 +10316,7 @@ std::pair<std::string, std::string>
     destructorLeave.clear();
   }
   std::string destructorCall =
-    destructorIt->first + "( " +
-    generateRAIIHandleDestructorCallArguments( parentType, handleType, destructorIt->second.params ) + " )";
+    destructorIt->first + "( " + generateRAIIHandleDestructorCallArguments( handleType, destructorIt ) + " )";
 
   const std::string destructorTemplate = R"(
 ${enter}~${handleType}()
@@ -10258,55 +10328,61 @@ ${enter}~${handleType}()
     }
 ${leave})";
 
-  std::string destructor = replaceWithMap( destructorTemplate,
-                                           { { "destructorCall", destructorCall },
-                                             { "enter", destructorEnter },
-                                             { "handleName", startLowerCase( stripPrefix( handleType, "Vk" ) ) },
-                                             { "handleType", stripPrefix( handleType, "Vk" ) },
-                                             { "leave", destructorLeave } } );
+  std::string destructor =
+    replaceWithMap( destructorTemplate,
+                    { { "destructorCall", destructorCall },
+                      { "enter", destructorEnter },
+                      { "handleName", generateRAIIHandleConstructorParamName( handleType, destructorIt ) },
+                      { "handleType", stripPrefix( handleType, "Vk" ) },
+                      { "leave", destructorLeave } } );
   return std::make_pair( destructor, destructorCall );
 }
 
-std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments( std::string const &            parentType,
-                                                                           std::string const &            handleType,
-                                                                           std::vector<ParamData> const & params ) const
+std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments(
+  std::string const & handleType, std::map<std::string, CommandData>::const_iterator destructorIt ) const
 {
   std::string arguments;
   bool        encounteredArgument = false;
-  for ( auto param : params )
+  for ( auto param : destructorIt->second.params )
   {
     if ( encounteredArgument )
     {
       arguments += ", ";
     }
-    if ( param.type.type == "VkAllocationCallbacks" )
+    if ( param.type.type == handleType )
     {
-      // VkAllocationCallbacks is stored as a member of the handle class
-      arguments += "m_allocator";
+      std::string handleName = param.name;
+      if ( param.type.isValue() )
+      {
+        arguments += "static_cast<" + handleType + ">( m_" + handleName + " )";
+      }
+      else
+      {
+        arguments += "reinterpret_cast<" + handleType + " const *>( &m_" +
+                     stripPluralS( startLowerCase( stripPrefix( handleName, "p" ) ) ) + " )";
+      }
+    }
+    else if ( param.type.type == "VkAllocationCallbacks" )
+    {
+      // vk::AllocationCallbacks is stored as a member of the handle class
+      arguments += "reinterpret_cast<const VkAllocationCallbacks *>( m_allocator )";
     }
     else if ( isHandleType( param.type.type ) )
     {
       assert( param.arraySizes.empty() );
-      std::string argument = "m_" + startLowerCase( stripPrefix( param.type.type, "Vk" ) );
+      std::string argument = "m_" + param.name;
       if ( param.type.isValue() )
       {
-        if ( param.type.type == parentType )
-        {
-          argument = "static_cast<" + param.type.type + ">( **" + argument + " )";
-        }
-        else if ( param.type.type == handleType )
-        {
-          argument = "static_cast<" + param.type.type + ">( " + argument + " )";
-        }
-        arguments += argument;
+        arguments += "static_cast<" + param.type.type + ">( " + argument + " )";
       }
       else
       {
         assert( param.type.isConstPointer() );
-        assert( !param.len.empty() &&
-                ( std::find_if( params.begin(),
-                                params.end(),
-                                [&param]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() ) );
+        assert( !param.len.empty() && ( std::find_if( destructorIt->second.params.begin(),
+                                                      destructorIt->second.params.end(),
+                                                      [&param]( ParamData const & pd ) {
+                                                        return pd.name == param.len;
+                                                      } ) != destructorIt->second.params.end() ) );
         arguments += "reinterpret_cast<" + param.type.type + " const *>( &" + argument + " )";
       }
     }
@@ -10314,9 +10390,10 @@ std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments( std::
     {
       assert( ( param.type.type == "uint32_t" ) && param.type.isValue() && param.arraySizes.empty() &&
               param.len.empty() && !param.optional );
-      assert( std::find_if( params.begin(),
-                            params.end(),
-                            [&param]( ParamData const & pd ) { return pd.len == param.name; } ) != params.end() );
+      assert( std::find_if( destructorIt->second.params.begin(),
+                            destructorIt->second.params.end(),
+                            [&param]( ParamData const & pd )
+                            { return pd.len == param.name; } ) != destructorIt->second.params.end() );
       arguments += "1";
     }
     encounteredArgument = true;
@@ -10342,25 +10419,10 @@ std::tuple<std::string, std::string, std::string, std::string>
 
   auto [parentType, parentName] = getParentTypeAndName( handle );
 
-  std::string moveConstructorInitializerList = "m_" + parentName +
-                                               "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
-                                               parentName + ", nullptr ) ), ";
-  std::string moveAssignmentInstructions = "          m_" + parentName +
-                                           " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
-                                           parentName + ", nullptr );\n";
-  std::string memberVariables =
-    "      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::" + parentType + " const * m_" + parentName + " = nullptr;";
-
   std::string handleType = stripPrefix( handle.first, "Vk" );
-  std::string handleName = startLowerCase( handleType );
-
-  moveConstructorInitializerList +=
-    "m_" + handleName + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName + ", {} ) )";
-  moveAssignmentInstructions += "        m_" + handleName +
-                                " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName +
-                                ", {} );";
-  memberVariables += "    VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + ";";
+  std::string handleName = generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt );
 
+  std::string moveConstructorInitializerList, moveAssignmentInstructions, memberVariables;
   if ( handle.second.destructorIt != m_commands.end() )
   {
     moveAssignmentInstructions = "        if ( m_" + handleName +
@@ -10369,42 +10431,79 @@ std::tuple<std::string, std::string, std::string, std::string>
                                  "          getDispatcher()->" +
                                  destructorCall +
                                  ";\n"
-                                 "        }\n"
-                                 "        " +
-                                 moveAssignmentInstructions;
+                                 "        }";
     for ( auto const & destructorParam : handle.second.destructorIt->second.params )
     {
-      if ( ( destructorParam.type.type != "Vk" + parentType ) && ( destructorParam.type.type != handle.first ) &&
-           ( std::find_if( handle.second.destructorIt->second.params.begin(),
-                           handle.second.destructorIt->second.params.end(),
-                           [&destructorParam]( ParamData const & pd ) { return pd.len == destructorParam.name; } ) ==
-             handle.second.destructorIt->second.params.end() ) )
+      if ( destructorParam.type.type == "Vk" + parentType )
+      {
+        moveConstructorInitializerList = "m_" + parentName +
+                                         "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                         parentName + ", {} ) ), ";
+        moveAssignmentInstructions = "\n          m_" + parentName +
+                                     " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                     parentName + ", {} );";
+        memberVariables = "\n    VULKAN_HPP_NAMESPACE::" + parentType + " m_" + parentName + " = {};";
+      }
+      else if ( destructorParam.type.type == handle.first )
+      {
+        moveConstructorInitializerList += "m_" + handleName +
+                                          "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                          handleName + ", {} ) ), ";
+        moveAssignmentInstructions += "\n          m_" + handleName +
+                                      " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                      handleName + ", {} );";
+        memberVariables += "\n    VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + " = {};";
+      }
+      else if ( std::find_if( handle.second.destructorIt->second.params.begin(),
+                              handle.second.destructorIt->second.params.end(),
+                              [&destructorParam]( ParamData const & pd ) { return pd.len == destructorParam.name; } ) ==
+                handle.second.destructorIt->second.params.end() )
       {
         std::string name = destructorParam.name;
         if ( !destructorParam.type.isValue() )
         {
           name = startLowerCase( stripPrefix( name, "p" ) );
         }
-        memberVariables += "\n    " + destructorParam.type.prefix + " " + destructorParam.type.type + " " +
-                           destructorParam.type.postfix + " m_" + name +
-                           ( destructorParam.type.postfix.empty() ? "" : " = nullptr" ) + ";";
-        moveConstructorInitializerList += ", m_" + name + "( rhs.m_" + name + " )";
-        moveAssignmentInstructions += "\n        m_" + name + " = rhs.m_" + name + ";";
+        memberVariables += "\n    " + destructorParam.type.compose( "VULKAN_HPP_NAMESPACE" ) + " m_" + name + " = " +
+                           ( destructorParam.type.postfix.empty() ? "{}" : "nullptr" ) + ";";
+        moveConstructorInitializerList +=
+          "m_" + name + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + name + ", {} ) ), ";
+        moveAssignmentInstructions += "\n        m_" + name +
+                                      " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + name +
+                                      ", {} );";
       }
     }
   }
-#if !defined( NDEBUG )
-  else if ( !handle.second.secondLevelCommands.empty() )
+  else
   {
-    assert( !handle.second.constructorIts.empty() );
-    assert( !handle.second.constructorIts.front()->second.params.empty() );
-    auto const & frontType = handle.second.constructorIts.front()->second.params.front().type.type;
-    assert( isHandleType( frontType ) );
-    auto handleIt = m_handles.find( "Vk" + parentType );
-    assert( handleIt != m_handles.end() );
-    assert( handleIt->second.parent == frontType );
+    if ( !handle.second.secondLevelCommands.empty() )
+    {
+      assert( !handle.second.constructorIts.empty() );
+      assert( !handle.second.constructorIts.front()->second.params.empty() );
+      auto const & frontType = handle.second.constructorIts.front()->second.params.front().type.type;
+      assert( isHandleType( frontType ) );
+      auto handleIt = m_handles.find( "Vk" + parentType );
+      assert( handleIt != m_handles.end() );
+      assert( handleIt->second.parent == frontType );
+      std::string frontName = handle.second.constructorIts.front()->second.params.front().name;
+
+      moveConstructorInitializerList = "m_" + frontName +
+                                       "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                       frontName + ", {} ) ), ";
+      moveAssignmentInstructions = "\n          m_" + frontName +
+                                   " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + frontName +
+                                   ", {} );";
+      memberVariables = "\n    VULKAN_HPP_NAMESPACE::" + stripPrefix( frontType, "Vk" ) + " m_" + frontName + " = {};";
+    }
+    moveConstructorInitializerList += "m_" + handleName +
+                                      "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                      handleName + ", {} ) ), ";
+    moveAssignmentInstructions += "\n          m_" + handleName +
+                                  " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName +
+                                  ", {} );";
+    memberVariables += "\n    VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + " = {};";
   }
-#endif
+
   if ( multiSuccessCodeContructor )
   {
     memberVariables += "\n    VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode;";
@@ -10433,13 +10532,13 @@ std::tuple<std::string, std::string, std::string, std::string>
 
   if ( ( handle.first == "VkInstance" ) || ( handle.first == "VkDevice" ) )
   {
-    moveConstructorInitializerList += ", m_dispatcher( rhs.m_dispatcher.release() )";
+    moveConstructorInitializerList += "m_dispatcher( rhs.m_dispatcher.release() )";
     moveAssignmentInstructions += "\n        m_dispatcher.reset( rhs.m_dispatcher.release() );";
   }
   else
   {
     moveConstructorInitializerList +=
-      ", m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )";
+      "m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )";
     moveAssignmentInstructions +=
       "\n        m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );";
   }
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index e4e286a..e67de99 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -1104,10 +1104,13 @@ private:
                                                       std::string const &                                enter,
                                                       std::string const &                                leave ) const;
   std::string
-              generateRAIIHandleConstructorInitializationList( std::pair<std::string, HandleData> const &         handle,
-                                                               std::map<std::string, CommandData>::const_iterator constructorIt,
-                                                               std::map<std::string, CommandData>::const_iterator destructorIt,
-                                                               bool takesOwnership ) const;
+    generateRAIIHandleConstructorInitializationList( std::pair<std::string, HandleData> const &         handle,
+                                                     std::map<std::string, CommandData>::const_iterator constructorIt,
+                                                     std::map<std::string, CommandData>::const_iterator destructorIt,
+                                                     bool takesOwnership ) const;
+  std::string
+              generateRAIIHandleConstructorParamName( std::string const &                                type,
+                                                      std::map<std::string, CommandData>::const_iterator destructorIt ) const;
   std::string generateRAIIHandleConstructorResult( std::pair<std::string, HandleData> const &         handle,
                                                    std::map<std::string, CommandData>::const_iterator constructorIt,
                                                    std::string const &                                enter,
@@ -1131,13 +1134,12 @@ private:
   std::string generateRAIIHandleContext( std::pair<std::string, HandleData> const & handle,
                                          std::set<std::string> const &              specialFunctions ) const;
   std::pair<std::string, std::string>
-              generateRAIIHandleDestructor( std::string const &                                parentType,
-                                            std::string const &                                handleType,
+              generateRAIIHandleDestructor( std::string const &                                handleType,
                                             std::map<std::string, CommandData>::const_iterator destructorIt,
                                             std::string const &                                enter ) const;
-  std::string generateRAIIHandleDestructorCallArguments( std::string const &            parentType,
-                                                         std::string const &            handleType,
-                                                         std::vector<ParamData> const & params ) const;
+  std::string
+    generateRAIIHandleDestructorCallArguments( std::string const &                                handleType,
+                                               std::map<std::string, CommandData>::const_iterator destructorIt ) const;
   std::tuple<std::string, std::string, std::string, std::string>
               generateRAIIHandleDetails( std::pair<std::string, HandleData> const & handle,
                                          std::string const &                        destructorCall ) const;
diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp
index 413a2f9..4c925f8 100644
--- a/vulkan/vulkan_raii.hpp
+++ b/vulkan/vulkan_raii.hpp
@@ -2372,13 +2372,11 @@ namespace VULKAN_HPP_NAMESPACE
       Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const &                context,
                 VULKAN_HPP_NAMESPACE::InstanceCreateInfo const &                                createInfo,
                 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_context( &context )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           context.getDispatcher()->vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
-                                                     m_allocator,
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                      reinterpret_cast<VkInstance *>( &m_instance ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -2391,10 +2389,8 @@ namespace VULKAN_HPP_NAMESPACE
       Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const &                context,
                 VkInstance                                                                      instance,
                 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_context( &context )
-        , m_instance( instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
       {
         m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher(
           context.getDispatcher()->vkGetInstanceProcAddr, static_cast<VkInstance>( m_instance ) ) );
@@ -2406,16 +2402,16 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_instance )
         {
-          getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), m_allocator );
+          getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ),
+                                              reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Instance()                   = delete;
       Instance( Instance const & ) = delete;
       Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_context( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_context, nullptr ) )
-        , m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( rhs.m_dispatcher.release() )
       {}
       Instance & operator=( Instance const & ) = delete;
@@ -2425,11 +2421,11 @@ namespace VULKAN_HPP_NAMESPACE
         {
           if ( m_instance )
           {
-            getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), m_allocator );
+            getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ),
+                                                reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
           }
-          m_context   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_context, nullptr );
           m_instance  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
-          m_allocator = rhs.m_allocator;
+          m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher.reset( rhs.m_dispatcher.release() );
         }
         return *this;
@@ -2440,11 +2436,6 @@ namespace VULKAN_HPP_NAMESPACE
         return m_instance;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const * getContext() const VULKAN_HPP_NOEXCEPT
-      {
-        return m_context;
-      }
-
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
       {
         VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -2609,9 +2600,8 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const *                     m_context = nullptr;
-      VULKAN_HPP_NAMESPACE::Instance                                                       m_instance;
-      const VkAllocationCallbacks *                                                        m_allocator = nullptr;
+      VULKAN_HPP_NAMESPACE::Instance                                                       m_instance  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                                    m_allocator = nullptr;
       std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher;
     };
 
@@ -2628,7 +2618,7 @@ namespace VULKAN_HPP_NAMESPACE
     public:
       PhysicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
                       VkPhysicalDevice                                                  physicalDevice )
-        : m_instance( &instance ), m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() )
+        : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() )
       {}
 
       PhysicalDevice( std::nullptr_t ) {}
@@ -2636,8 +2626,7 @@ namespace VULKAN_HPP_NAMESPACE
       PhysicalDevice()                         = delete;
       PhysicalDevice( PhysicalDevice const & ) = delete;
       PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) )
-        , m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
+        : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       PhysicalDevice & operator=( PhysicalDevice const & ) = delete;
@@ -2645,7 +2634,6 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          m_instance       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr );
           m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
           m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
@@ -2657,11 +2645,6 @@ namespace VULKAN_HPP_NAMESPACE
         return m_physicalDevice;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT
-      {
-        return m_instance;
-      }
-
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
       {
         VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -3010,9 +2993,8 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const *           m_instance = nullptr;
-      VULKAN_HPP_NAMESPACE::PhysicalDevice                                        m_physicalDevice;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::PhysicalDevice                                        m_physicalDevice = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher     = nullptr;
     };
 
     class PhysicalDevices : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>
@@ -3072,15 +3054,14 @@ namespace VULKAN_HPP_NAMESPACE
       Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &         physicalDevice,
               VULKAN_HPP_NAMESPACE::DeviceCreateInfo const &                                  createInfo,
               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_physicalDevice( &physicalDevice )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
       {
-        VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          physicalDevice.getDispatcher()->vkCreateDevice( static_cast<VkPhysicalDevice>( *physicalDevice ),
-                                                          reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
-                                                          m_allocator,
-                                                          reinterpret_cast<VkDevice *>( &m_device ) ) );
+        VULKAN_HPP_NAMESPACE::Result result =
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( physicalDevice.getDispatcher()->vkCreateDevice(
+            static_cast<VkPhysicalDevice>( *physicalDevice ),
+            reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkDevice *>( &m_device ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateDevice" );
@@ -3092,10 +3073,7 @@ namespace VULKAN_HPP_NAMESPACE
       Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &         physicalDevice,
               VkDevice                                                                        device,
               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_physicalDevice( &physicalDevice )
-        , m_device( device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( device ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
       {
         m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher(
           physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast<VkDevice>( m_device ) ) );
@@ -3107,16 +3085,16 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_device )
         {
-          getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), m_allocator );
+          getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ),
+                                            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Device()                 = delete;
       Device( Device const & ) = delete;
       Device( Device && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr ) )
-        , m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( rhs.m_dispatcher.release() )
       {}
       Device & operator=( Device const & ) = delete;
@@ -3126,11 +3104,11 @@ namespace VULKAN_HPP_NAMESPACE
         {
           if ( m_device )
           {
-            getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), m_allocator );
+            getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ),
+                                              reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
           }
-          m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr );
-          m_device         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
-          m_allocator      = rhs.m_allocator;
+          m_device    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher.reset( rhs.m_dispatcher.release() );
         }
         return *this;
@@ -3141,12 +3119,6 @@ namespace VULKAN_HPP_NAMESPACE
         return m_device;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const *
-        getPhysicalDevice() const VULKAN_HPP_NOEXCEPT
-      {
-        return m_physicalDevice;
-      }
-
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
       {
         VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -3831,9 +3803,8 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const *            m_physicalDevice = nullptr;
-      VULKAN_HPP_NAMESPACE::Device                                                       m_device;
-      const VkAllocationCallbacks *                                                      m_allocator = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                                       m_device    = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                                  m_allocator = nullptr;
       std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher;
     };
 
@@ -3852,17 +3823,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &                createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateAccelerationStructureKHR(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkAccelerationStructureKHR *>( &m_accelerationStructureKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkAccelerationStructureKHR *>( &m_accelerationStructure ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateAccelerationStructureKHR" );
@@ -3871,12 +3841,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       AccelerationStructureKHR(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkAccelerationStructureKHR                                                      accelerationStructureKHR,
+        VkAccelerationStructureKHR                                                      accelerationStructure,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_accelerationStructureKHR( accelerationStructureKHR )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_accelerationStructure( accelerationStructure )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -3884,22 +3853,22 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~AccelerationStructureKHR()
       {
-        if ( m_accelerationStructureKHR )
+        if ( m_accelerationStructure )
         {
           getDispatcher()->vkDestroyAccelerationStructureKHR(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkAccelerationStructureKHR>( m_accelerationStructureKHR ),
-            m_allocator );
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkAccelerationStructureKHR>( m_accelerationStructure ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       AccelerationStructureKHR()                                   = delete;
       AccelerationStructureKHR( AccelerationStructureKHR const & ) = delete;
       AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_accelerationStructureKHR(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_accelerationStructure(
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete;
@@ -3907,17 +3876,10 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_accelerationStructureKHR )
-          {
-            getDispatcher()->vkDestroyAccelerationStructureKHR(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkAccelerationStructureKHR>( m_accelerationStructureKHR ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_accelerationStructureKHR =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} );
-          m_allocator  = rhs.m_allocator;
+          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_accelerationStructure =
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -3925,10 +3887,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_accelerationStructureKHR;
+        return m_accelerationStructure;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -3940,10 +3902,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                            m_accelerationStructureKHR;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device                = {};
+      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                            m_accelerationStructure = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator             = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher            = nullptr;
     };
 
     class AccelerationStructureNV
@@ -3961,17 +3923,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &                 createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateAccelerationStructureNV(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkAccelerationStructureNV *>( &m_accelerationStructureNV ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkAccelerationStructureNV *>( &m_accelerationStructure ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateAccelerationStructureNV" );
@@ -3980,12 +3941,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       AccelerationStructureNV(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkAccelerationStructureNV                                                       accelerationStructureNV,
+        VkAccelerationStructureNV                                                       accelerationStructure,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_accelerationStructureNV( accelerationStructureNV )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_accelerationStructure( accelerationStructure )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -3993,22 +3953,22 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~AccelerationStructureNV()
       {
-        if ( m_accelerationStructureNV )
+        if ( m_accelerationStructure )
         {
           getDispatcher()->vkDestroyAccelerationStructureNV(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
-            m_allocator );
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       AccelerationStructureNV()                                  = delete;
       AccelerationStructureNV( AccelerationStructureNV const & ) = delete;
       AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_accelerationStructureNV(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_accelerationStructure(
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete;
@@ -4016,17 +3976,10 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_accelerationStructureNV )
-          {
-            getDispatcher()->vkDestroyAccelerationStructureNV(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_accelerationStructureNV =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} );
-          m_allocator  = rhs.m_allocator;
+          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_accelerationStructure =
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -4034,10 +3987,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_accelerationStructureNV;
+        return m_accelerationStructure;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -4057,10 +4010,10 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD T getHandle() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV                             m_accelerationStructureNV;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device                = {};
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV                             m_accelerationStructure = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator             = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher            = nullptr;
     };
 
     class Buffer
@@ -4077,15 +4030,14 @@ namespace VULKAN_HPP_NAMESPACE
       Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
               VULKAN_HPP_NAMESPACE::BufferCreateInfo const &                                  createInfo,
               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateBuffer( static_cast<VkDevice>( *device ),
                                                   reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
-                                                  m_allocator,
+                                                  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                   reinterpret_cast<VkBuffer *>( &m_buffer ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -4096,10 +4048,9 @@ namespace VULKAN_HPP_NAMESPACE
       Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
               VkBuffer                                                                        buffer,
               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_buffer( buffer )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -4109,17 +4060,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_buffer )
         {
-          getDispatcher()->vkDestroyBuffer(
-            static_cast<VkDevice>( **m_device ), static_cast<VkBuffer>( m_buffer ), m_allocator );
+          getDispatcher()->vkDestroyBuffer( static_cast<VkDevice>( m_device ),
+                                            static_cast<VkBuffer>( m_buffer ),
+                                            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Buffer()                 = delete;
       Buffer( Buffer const & ) = delete;
       Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Buffer & operator=( Buffer const & ) = delete;
@@ -4127,14 +4079,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_buffer )
-          {
-            getDispatcher()->vkDestroyBuffer(
-              static_cast<VkDevice>( **m_device ), static_cast<VkBuffer>( m_buffer ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_buffer     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -4145,7 +4092,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_buffer;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -4163,9 +4110,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Buffer                                              m_buffer;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::Buffer                                              m_buffer     = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -4185,17 +4132,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &                 createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateBufferCollectionFUCHSIA(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkBufferCollectionFUCHSIA *>( &m_bufferCollectionFUCHSIA ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkBufferCollectionFUCHSIA *>( &m_collection ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateBufferCollectionFUCHSIA" );
@@ -4204,12 +4150,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       BufferCollectionFUCHSIA(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkBufferCollectionFUCHSIA                                                       bufferCollectionFUCHSIA,
+        VkBufferCollectionFUCHSIA                                                       collection,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_collection( collection )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -4217,22 +4162,21 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~BufferCollectionFUCHSIA()
       {
-        if ( m_bufferCollectionFUCHSIA )
+        if ( m_collection )
         {
           getDispatcher()->vkDestroyBufferCollectionFUCHSIA(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkBufferCollectionFUCHSIA>( m_bufferCollectionFUCHSIA ),
-            m_allocator );
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       BufferCollectionFUCHSIA()                                  = delete;
       BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete;
       BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_bufferCollectionFUCHSIA(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_collection( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete;
@@ -4240,17 +4184,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_bufferCollectionFUCHSIA )
-          {
-            getDispatcher()->vkDestroyBufferCollectionFUCHSIA(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkBufferCollectionFUCHSIA>( m_bufferCollectionFUCHSIA ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_bufferCollectionFUCHSIA =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} );
-          m_allocator  = rhs.m_allocator;
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_collection = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -4258,10 +4194,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_bufferCollectionFUCHSIA;
+        return m_collection;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -4282,9 +4218,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                             m_bufferCollectionFUCHSIA;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                             m_collection = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
@@ -4303,15 +4239,14 @@ namespace VULKAN_HPP_NAMESPACE
       BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                   VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const &                              createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateBufferView( static_cast<VkDevice>( *device ),
                                                       reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
-                                                      m_allocator,
+                                                      reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                       reinterpret_cast<VkBufferView *>( &m_bufferView ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -4322,10 +4257,9 @@ namespace VULKAN_HPP_NAMESPACE
       BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                   VkBufferView                                                                    bufferView,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_bufferView( bufferView )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -4335,17 +4269,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_bufferView )
         {
-          getDispatcher()->vkDestroyBufferView(
-            static_cast<VkDevice>( **m_device ), static_cast<VkBufferView>( m_bufferView ), m_allocator );
+          getDispatcher()->vkDestroyBufferView( static_cast<VkDevice>( m_device ),
+                                                static_cast<VkBufferView>( m_bufferView ),
+                                                reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       BufferView()                     = delete;
       BufferView( BufferView const & ) = delete;
       BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_bufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       BufferView & operator=( BufferView const & ) = delete;
@@ -4353,14 +4288,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_bufferView )
-          {
-            getDispatcher()->vkDestroyBufferView(
-              static_cast<VkDevice>( **m_device ), static_cast<VkBufferView>( m_bufferView ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_bufferView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -4371,7 +4301,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_bufferView;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -4383,9 +4313,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::BufferView                                          m_bufferView;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::BufferView                                          m_bufferView = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -4403,15 +4333,14 @@ namespace VULKAN_HPP_NAMESPACE
       CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const &                             createInfo,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateCommandPool( static_cast<VkDevice>( *device ),
                                                        reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
-                                                       m_allocator,
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                        reinterpret_cast<VkCommandPool *>( &m_commandPool ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -4422,10 +4351,9 @@ namespace VULKAN_HPP_NAMESPACE
       CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VkCommandPool                                                                   commandPool,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_commandPool( commandPool )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -4435,17 +4363,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_commandPool )
         {
-          getDispatcher()->vkDestroyCommandPool(
-            static_cast<VkDevice>( **m_device ), static_cast<VkCommandPool>( m_commandPool ), m_allocator );
+          getDispatcher()->vkDestroyCommandPool( static_cast<VkDevice>( m_device ),
+                                                 static_cast<VkCommandPool>( m_commandPool ),
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       CommandPool()                      = delete;
       CommandPool( CommandPool const & ) = delete;
       CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       CommandPool & operator=( CommandPool const & ) = delete;
@@ -4453,14 +4382,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_commandPool )
-          {
-            getDispatcher()->vkDestroyCommandPool(
-              static_cast<VkDevice>( **m_device ), static_cast<VkCommandPool>( m_commandPool ), m_allocator );
-          }
-          m_device      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} );
-          m_allocator   = rhs.m_allocator;
+          m_allocator   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -4471,7 +4395,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_commandPool;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -4497,10 +4421,10 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::CommandPool                                         m_commandPool;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device      = {};
+      VULKAN_HPP_NAMESPACE::CommandPool                                         m_commandPool = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator   = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher  = nullptr;
     };
 
     class CommandBuffer
@@ -4517,9 +4441,9 @@ namespace VULKAN_HPP_NAMESPACE
       CommandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
                      VkCommandBuffer                                                 commandBuffer,
                      VkCommandPool                                                   commandPool )
-        : m_device( &device )
-        , m_commandBuffer( commandBuffer )
+        : m_device( *device )
         , m_commandPool( commandPool )
+        , m_commandBuffer( commandBuffer )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -4529,8 +4453,8 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_commandBuffer )
         {
-          getDispatcher()->vkFreeCommandBuffers( static_cast<VkDevice>( **m_device ),
-                                                 m_commandPool,
+          getDispatcher()->vkFreeCommandBuffers( static_cast<VkDevice>( m_device ),
+                                                 static_cast<VkCommandPool>( m_commandPool ),
                                                  1,
                                                  reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) );
         }
@@ -4539,9 +4463,9 @@ namespace VULKAN_HPP_NAMESPACE
       CommandBuffer()                        = delete;
       CommandBuffer( CommandBuffer const & ) = delete;
       CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
         , m_commandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) )
-        , m_commandPool( rhs.m_commandPool )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       CommandBuffer & operator=( CommandBuffer const & ) = delete;
@@ -4549,16 +4473,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_commandBuffer )
-          {
-            getDispatcher()->vkFreeCommandBuffers( static_cast<VkDevice>( **m_device ),
-                                                   m_commandPool,
-                                                   1,
-                                                   reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) );
-          }
-          m_device        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_commandPool   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} );
           m_commandBuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} );
-          m_commandPool   = rhs.m_commandPool;
           m_dispatcher    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -4569,7 +4486,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_commandBuffer;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -5300,10 +5217,10 @@ namespace VULKAN_HPP_NAMESPACE
                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::CommandBuffer                                       m_commandBuffer;
-      VkCommandPool                                                             m_commandPool;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device        = {};
+      VULKAN_HPP_NAMESPACE::CommandPool                                         m_commandPool   = {};
+      VULKAN_HPP_NAMESPACE::CommandBuffer                                       m_commandBuffer = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher    = nullptr;
     };
 
     class CommandBuffers : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>
@@ -5354,17 +5271,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const &                           createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateCuFunctionNVX(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkCuFunctionNVX *>( &m_cuFunctionNVX ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkCuFunctionNVX *>( &m_function ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateCuFunctionNVX" );
@@ -5373,12 +5289,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       CuFunctionNVX(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkCuFunctionNVX                                                                 cuFunctionNVX,
+        VkCuFunctionNVX                                                                 function,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_cuFunctionNVX( cuFunctionNVX )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_function( function )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -5386,19 +5301,20 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~CuFunctionNVX()
       {
-        if ( m_cuFunctionNVX )
+        if ( m_function )
         {
-          getDispatcher()->vkDestroyCuFunctionNVX(
-            static_cast<VkDevice>( **m_device ), static_cast<VkCuFunctionNVX>( m_cuFunctionNVX ), m_allocator );
+          getDispatcher()->vkDestroyCuFunctionNVX( static_cast<VkDevice>( m_device ),
+                                                   static_cast<VkCuFunctionNVX>( m_function ),
+                                                   reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       CuFunctionNVX()                        = delete;
       CuFunctionNVX( CuFunctionNVX const & ) = delete;
       CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_cuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_function( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete;
@@ -5406,25 +5322,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_cuFunctionNVX )
-          {
-            getDispatcher()->vkDestroyCuFunctionNVX(
-              static_cast<VkDevice>( **m_device ), static_cast<VkCuFunctionNVX>( m_cuFunctionNVX ), m_allocator );
-          }
-          m_device        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_cuFunctionNVX = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} );
-          m_allocator     = rhs.m_allocator;
-          m_dispatcher    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_function   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_cuFunctionNVX;
+        return m_function;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -5436,9 +5347,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::CuFunctionNVX                                       m_cuFunctionNVX;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::CuFunctionNVX                                       m_function   = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -5456,16 +5367,15 @@ namespace VULKAN_HPP_NAMESPACE
       CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const &                             createInfo,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateCuModuleNVX( static_cast<VkDevice>( *device ),
                                                        reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
-                                                       m_allocator,
-                                                       reinterpret_cast<VkCuModuleNVX *>( &m_cuModuleNVX ) ) );
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+                                                       reinterpret_cast<VkCuModuleNVX *>( &m_module ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateCuModuleNVX" );
@@ -5473,12 +5383,11 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
       CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-                   VkCuModuleNVX                                                                   cuModuleNVX,
+                   VkCuModuleNVX                                                                   module,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_cuModuleNVX( cuModuleNVX )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_module( module )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -5486,19 +5395,20 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~CuModuleNVX()
       {
-        if ( m_cuModuleNVX )
+        if ( m_module )
         {
-          getDispatcher()->vkDestroyCuModuleNVX(
-            static_cast<VkDevice>( **m_device ), static_cast<VkCuModuleNVX>( m_cuModuleNVX ), m_allocator );
+          getDispatcher()->vkDestroyCuModuleNVX( static_cast<VkDevice>( m_device ),
+                                                 static_cast<VkCuModuleNVX>( m_module ),
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       CuModuleNVX()                      = delete;
       CuModuleNVX( CuModuleNVX const & ) = delete;
       CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_cuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_module( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       CuModuleNVX & operator=( CuModuleNVX const & ) = delete;
@@ -5506,25 +5416,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_cuModuleNVX )
-          {
-            getDispatcher()->vkDestroyCuModuleNVX(
-              static_cast<VkDevice>( **m_device ), static_cast<VkCuModuleNVX>( m_cuModuleNVX ), m_allocator );
-          }
-          m_device      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_cuModuleNVX = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} );
-          m_allocator   = rhs.m_allocator;
-          m_dispatcher  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_module     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_cuModuleNVX;
+        return m_module;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -5536,9 +5441,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::CuModuleNVX                                         m_cuModuleNVX;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::CuModuleNVX                                         m_module     = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -5557,17 +5462,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
         VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const &                  createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDebugReportCallbackEXT(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkDebugReportCallbackEXT *>( &m_debugReportCallbackEXT ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkDebugReportCallbackEXT *>( &m_callback ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateDebugReportCallbackEXT" );
@@ -5576,12 +5480,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       DebugReportCallbackEXT(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
-        VkDebugReportCallbackEXT                                                        debugReportCallbackEXT,
+        VkDebugReportCallbackEXT                                                        callback,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_debugReportCallbackEXT( debugReportCallbackEXT )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_callback( callback )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {}
 
@@ -5589,22 +5492,21 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~DebugReportCallbackEXT()
       {
-        if ( m_debugReportCallbackEXT )
+        if ( m_callback )
         {
           getDispatcher()->vkDestroyDebugReportCallbackEXT(
-            static_cast<VkInstance>( **m_instance ),
-            static_cast<VkDebugReportCallbackEXT>( m_debugReportCallbackEXT ),
-            m_allocator );
+            static_cast<VkInstance>( m_instance ),
+            static_cast<VkDebugReportCallbackEXT>( m_callback ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       DebugReportCallbackEXT()                                 = delete;
       DebugReportCallbackEXT( DebugReportCallbackEXT const & ) = delete;
       DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) )
-        , m_debugReportCallbackEXT(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
+        , m_callback( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete;
@@ -5612,17 +5514,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_debugReportCallbackEXT )
-          {
-            getDispatcher()->vkDestroyDebugReportCallbackEXT(
-              static_cast<VkInstance>( **m_instance ),
-              static_cast<VkDebugReportCallbackEXT>( m_debugReportCallbackEXT ),
-              m_allocator );
-          }
-          m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr );
-          m_debugReportCallbackEXT =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} );
-          m_allocator  = rhs.m_allocator;
+          m_instance   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
+          m_callback   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -5630,10 +5524,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_debugReportCallbackEXT;
+        return m_callback;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Instance getInstance() const
       {
         return m_instance;
       }
@@ -5645,9 +5539,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const *           m_instance = nullptr;
-      VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                                m_debugReportCallbackEXT;
-      const VkAllocationCallbacks *                                               m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Instance                                              m_instance   = {};
+      VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                                m_callback   = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -5666,17 +5560,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
         VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const &                  createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDebugUtilsMessengerEXT(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_debugUtilsMessengerEXT ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_messenger ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateDebugUtilsMessengerEXT" );
@@ -5685,12 +5578,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       DebugUtilsMessengerEXT(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
-        VkDebugUtilsMessengerEXT                                                        debugUtilsMessengerEXT,
+        VkDebugUtilsMessengerEXT                                                        messenger,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_messenger( messenger )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {}
 
@@ -5698,22 +5590,21 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~DebugUtilsMessengerEXT()
       {
-        if ( m_debugUtilsMessengerEXT )
+        if ( m_messenger )
         {
           getDispatcher()->vkDestroyDebugUtilsMessengerEXT(
-            static_cast<VkInstance>( **m_instance ),
-            static_cast<VkDebugUtilsMessengerEXT>( m_debugUtilsMessengerEXT ),
-            m_allocator );
+            static_cast<VkInstance>( m_instance ),
+            static_cast<VkDebugUtilsMessengerEXT>( m_messenger ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       DebugUtilsMessengerEXT()                                 = delete;
       DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete;
       DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) )
-        , m_debugUtilsMessengerEXT(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
+        , m_messenger( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete;
@@ -5721,17 +5612,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_debugUtilsMessengerEXT )
-          {
-            getDispatcher()->vkDestroyDebugUtilsMessengerEXT(
-              static_cast<VkInstance>( **m_instance ),
-              static_cast<VkDebugUtilsMessengerEXT>( m_debugUtilsMessengerEXT ),
-              m_allocator );
-          }
-          m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr );
-          m_debugUtilsMessengerEXT =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} );
-          m_allocator  = rhs.m_allocator;
+          m_instance   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
+          m_messenger  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -5739,10 +5622,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_debugUtilsMessengerEXT;
+        return m_messenger;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Instance getInstance() const
       {
         return m_instance;
       }
@@ -5754,9 +5637,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const *           m_instance = nullptr;
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT                                m_debugUtilsMessengerEXT;
-      const VkAllocationCallbacks *                                               m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Instance                                              m_instance   = {};
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT                                m_messenger  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -5774,16 +5657,15 @@ namespace VULKAN_HPP_NAMESPACE
       DeferredOperationKHR(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDeferredOperationKHR(
             static_cast<VkDevice>( *device ),
-            m_allocator,
-            reinterpret_cast<VkDeferredOperationKHR *>( &m_deferredOperationKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkDeferredOperationKHR *>( &m_operation ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateDeferredOperationKHR" );
@@ -5792,12 +5674,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       DeferredOperationKHR(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkDeferredOperationKHR                                                          deferredOperationKHR,
+        VkDeferredOperationKHR                                                          operation,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_deferredOperationKHR( deferredOperationKHR )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_operation( operation )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -5805,21 +5686,21 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~DeferredOperationKHR()
       {
-        if ( m_deferredOperationKHR )
+        if ( m_operation )
         {
-          getDispatcher()->vkDestroyDeferredOperationKHR( static_cast<VkDevice>( **m_device ),
-                                                          static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ),
-                                                          m_allocator );
+          getDispatcher()->vkDestroyDeferredOperationKHR(
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkDeferredOperationKHR>( m_operation ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       DeferredOperationKHR()                               = delete;
       DeferredOperationKHR( DeferredOperationKHR const & ) = delete;
       DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_deferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deferredOperationKHR,
-                                                                                             {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_operation( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete;
@@ -5827,17 +5708,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_deferredOperationKHR )
-          {
-            getDispatcher()->vkDestroyDeferredOperationKHR(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_deferredOperationKHR =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} );
-          m_allocator  = rhs.m_allocator;
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_operation  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -5845,10 +5718,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_deferredOperationKHR;
+        return m_operation;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -5868,9 +5741,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                m_deferredOperationKHR;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                m_operation  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -5889,16 +5762,15 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const &                          createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDescriptorPool(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkDescriptorPool *>( &m_descriptorPool ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -5910,10 +5782,9 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VkDescriptorPool                                                                descriptorPool,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_descriptorPool( descriptorPool )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -5923,17 +5794,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_descriptorPool )
         {
-          getDispatcher()->vkDestroyDescriptorPool(
-            static_cast<VkDevice>( **m_device ), static_cast<VkDescriptorPool>( m_descriptorPool ), m_allocator );
+          getDispatcher()->vkDestroyDescriptorPool( static_cast<VkDevice>( m_device ),
+                                                    static_cast<VkDescriptorPool>( m_descriptorPool ),
+                                                    reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       DescriptorPool()                         = delete;
       DescriptorPool( DescriptorPool const & ) = delete;
       DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DescriptorPool & operator=( DescriptorPool const & ) = delete;
@@ -5941,14 +5813,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_descriptorPool )
-          {
-            getDispatcher()->vkDestroyDescriptorPool(
-              static_cast<VkDevice>( **m_device ), static_cast<VkDescriptorPool>( m_descriptorPool ), m_allocator );
-          }
-          m_device         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
-          m_allocator      = rhs.m_allocator;
+          m_allocator      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -5959,7 +5826,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorPool;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -5976,10 +5843,10 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::DescriptorPool                                      m_descriptorPool;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device         = {};
+      VULKAN_HPP_NAMESPACE::DescriptorPool                                      m_descriptorPool = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator      = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher     = nullptr;
     };
 
     class DescriptorSet
@@ -5996,9 +5863,9 @@ namespace VULKAN_HPP_NAMESPACE
       DescriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
                      VkDescriptorSet                                                 descriptorSet,
                      VkDescriptorPool                                                descriptorPool )
-        : m_device( &device )
-        , m_descriptorSet( descriptorSet )
+        : m_device( *device )
         , m_descriptorPool( descriptorPool )
+        , m_descriptorSet( descriptorSet )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -6008,8 +5875,8 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_descriptorSet )
         {
-          getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( **m_device ),
-                                                 m_descriptorPool,
+          getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( m_device ),
+                                                 static_cast<VkDescriptorPool>( m_descriptorPool ),
                                                  1,
                                                  reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) );
         }
@@ -6018,9 +5885,9 @@ namespace VULKAN_HPP_NAMESPACE
       DescriptorSet()                        = delete;
       DescriptorSet( DescriptorSet const & ) = delete;
       DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
         , m_descriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) )
-        , m_descriptorPool( rhs.m_descriptorPool )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DescriptorSet & operator=( DescriptorSet const & ) = delete;
@@ -6028,16 +5895,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_descriptorSet )
-          {
-            getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( **m_device ),
-                                                   m_descriptorPool,
-                                                   1,
-                                                   reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) );
-          }
-          m_device         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
           m_descriptorSet  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} );
-          m_descriptorPool = rhs.m_descriptorPool;
           m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -6048,7 +5908,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorSet;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -6070,10 +5930,10 @@ namespace VULKAN_HPP_NAMESPACE
                                   const void *                                   pData ) const VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::DescriptorSet                                       m_descriptorSet;
-      VkDescriptorPool                                                          m_descriptorPool;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device         = {};
+      VULKAN_HPP_NAMESPACE::DescriptorPool                                      m_descriptorPool = {};
+      VULKAN_HPP_NAMESPACE::DescriptorSet                                       m_descriptorSet  = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher     = nullptr;
     };
 
     class DescriptorSets : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>
@@ -6124,16 +5984,15 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const &                     createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDescriptorSetLayout(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkDescriptorSetLayout *>( &m_descriptorSetLayout ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -6145,10 +6004,9 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VkDescriptorSetLayout                                                           descriptorSetLayout,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_descriptorSetLayout( descriptorSetLayout )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -6158,19 +6016,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_descriptorSetLayout )
         {
-          getDispatcher()->vkDestroyDescriptorSetLayout( static_cast<VkDevice>( **m_device ),
-                                                         static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
-                                                         m_allocator );
+          getDispatcher()->vkDestroyDescriptorSetLayout(
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       DescriptorSetLayout()                              = delete;
       DescriptorSetLayout( DescriptorSetLayout const & ) = delete;
       DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout,
                                                                                             {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete;
@@ -6178,16 +6037,10 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_descriptorSetLayout )
-          {
-            getDispatcher()->vkDestroyDescriptorSetLayout( static_cast<VkDevice>( **m_device ),
-                                                           static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
-                                                           m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_descriptorSetLayout =
             VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -6198,7 +6051,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorSetLayout;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -6210,10 +6063,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::DescriptorSetLayout                                 m_descriptorSetLayout;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device              = {};
+      VULKAN_HPP_NAMESPACE::DescriptorSetLayout                                 m_descriptorSetLayout = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator           = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher          = nullptr;
     };
 
     class DescriptorUpdateTemplate
@@ -6231,16 +6084,15 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &                createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDescriptorUpdateTemplate(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkDescriptorUpdateTemplate *>( &m_descriptorUpdateTemplate ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -6252,10 +6104,9 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VkDescriptorUpdateTemplate                                                      descriptorUpdateTemplate,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_descriptorUpdateTemplate( descriptorUpdateTemplate )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -6266,19 +6117,19 @@ namespace VULKAN_HPP_NAMESPACE
         if ( m_descriptorUpdateTemplate )
         {
           getDispatcher()->vkDestroyDescriptorUpdateTemplate(
-            static_cast<VkDevice>( **m_device ),
+            static_cast<VkDevice>( m_device ),
             static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ),
-            m_allocator );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       DescriptorUpdateTemplate()                                   = delete;
       DescriptorUpdateTemplate( DescriptorUpdateTemplate const & ) = delete;
       DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_descriptorUpdateTemplate(
             VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete;
@@ -6286,17 +6137,10 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_descriptorUpdateTemplate )
-          {
-            getDispatcher()->vkDestroyDescriptorUpdateTemplate(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_descriptorUpdateTemplate =
             VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -6307,7 +6151,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorUpdateTemplate;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -6319,10 +6163,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                            m_descriptorUpdateTemplate;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device                   = {};
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                            m_descriptorUpdateTemplate = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator                = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher               = nullptr;
     };
 
     class DeviceMemory
@@ -6340,16 +6184,15 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const &                                allocateInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkAllocateMemory( static_cast<VkDevice>( *device ),
                                                     reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
-                                                    m_allocator,
-                                                    reinterpret_cast<VkDeviceMemory *>( &m_deviceMemory ) ) );
+                                                    reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+                                                    reinterpret_cast<VkDeviceMemory *>( &m_memory ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkAllocateMemory" );
@@ -6358,12 +6201,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       DeviceMemory(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkDeviceMemory                                                                  deviceMemory,
+        VkDeviceMemory                                                                  memory,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_deviceMemory( deviceMemory )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_memory( memory )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -6371,19 +6213,20 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~DeviceMemory()
       {
-        if ( m_deviceMemory )
+        if ( m_memory )
         {
-          getDispatcher()->vkFreeMemory(
-            static_cast<VkDevice>( **m_device ), static_cast<VkDeviceMemory>( m_deviceMemory ), m_allocator );
+          getDispatcher()->vkFreeMemory( static_cast<VkDevice>( m_device ),
+                                         static_cast<VkDeviceMemory>( m_memory ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       DeviceMemory()                       = delete;
       DeviceMemory( DeviceMemory const & ) = delete;
       DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_deviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deviceMemory, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_memory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DeviceMemory & operator=( DeviceMemory const & ) = delete;
@@ -6391,25 +6234,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_deviceMemory )
-          {
-            getDispatcher()->vkFreeMemory(
-              static_cast<VkDevice>( **m_device ), static_cast<VkDeviceMemory>( m_deviceMemory ), m_allocator );
-          }
-          m_device       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_deviceMemory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deviceMemory, {} );
-          m_allocator    = rhs.m_allocator;
-          m_dispatcher   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_memory     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_deviceMemory;
+        return m_memory;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -6443,9 +6281,9 @@ namespace VULKAN_HPP_NAMESPACE
       void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::DeviceMemory                                        m_deviceMemory;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::DeviceMemory                                        m_memory     = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -6463,13 +6301,13 @@ namespace VULKAN_HPP_NAMESPACE
       DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,
                   int32_t                                                                 drmFd,
                   uint32_t                                                                connectorId )
-        : m_physicalDevice( &physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
+        : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           physicalDevice.getDispatcher()->vkGetDrmDisplayEXT( static_cast<VkPhysicalDevice>( *physicalDevice ),
                                                               drmFd,
                                                               connectorId,
-                                                              reinterpret_cast<VkDisplayKHR *>( &m_displayKHR ) ) );
+                                                              reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkGetDrmDisplayEXT" );
@@ -6480,14 +6318,14 @@ namespace VULKAN_HPP_NAMESPACE
       DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,
                   Display &                                                               dpy,
                   RROutput                                                                rrOutput )
-        : m_physicalDevice( &physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
+        : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( physicalDevice.getDispatcher()->vkGetRandROutputDisplayEXT(
             static_cast<VkPhysicalDevice>( *physicalDevice ),
             &dpy,
             rrOutput,
-            reinterpret_cast<VkDisplayKHR *>( &m_displayKHR ) ) );
+            reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkGetRandROutputDisplayEXT" );
@@ -6498,12 +6336,12 @@ namespace VULKAN_HPP_NAMESPACE
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
       DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,
                   uint32_t                                                                deviceRelativeId )
-        : m_physicalDevice( &physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
+        : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           physicalDevice.getDispatcher()->vkGetWinrtDisplayNV( static_cast<VkPhysicalDevice>( *physicalDevice ),
                                                                deviceRelativeId,
-                                                               reinterpret_cast<VkDisplayKHR *>( &m_displayKHR ) ) );
+                                                               reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkGetWinrtDisplayNV" );
@@ -6512,28 +6350,26 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
       DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,
-                  VkDisplayKHR                                                            displayKHR )
-        : m_physicalDevice( &physicalDevice )
-        , m_displayKHR( displayKHR )
-        , m_dispatcher( physicalDevice.getDispatcher() )
+                  VkDisplayKHR                                                            display )
+        : m_physicalDevice( *physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() )
       {}
 
       DisplayKHR( std::nullptr_t ) {}
 
       ~DisplayKHR()
       {
-        if ( m_displayKHR )
+        if ( m_display )
         {
-          getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( **m_physicalDevice ),
-                                                static_cast<VkDisplayKHR>( m_displayKHR ) );
+          getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                static_cast<VkDisplayKHR>( m_display ) );
         }
       }
 
       DisplayKHR()                     = delete;
       DisplayKHR( DisplayKHR const & ) = delete;
       DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr ) )
-        , m_displayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayKHR, {} ) )
+        : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
+        , m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DisplayKHR & operator=( DisplayKHR const & ) = delete;
@@ -6541,13 +6377,8 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_displayKHR )
-          {
-            getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( **m_physicalDevice ),
-                                                  static_cast<VkDisplayKHR>( m_displayKHR ) );
-          }
-          m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr );
-          m_displayKHR     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayKHR, {} );
+          m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
+          m_display        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} );
           m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -6555,11 +6386,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_displayKHR;
+        return m_display;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const *
-        getPhysicalDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const
       {
         return m_physicalDevice;
       }
@@ -6589,9 +6419,9 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const *     m_physicalDevice = nullptr;
-      VULKAN_HPP_NAMESPACE::DisplayKHR                                            m_displayKHR;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::PhysicalDevice                                        m_physicalDevice = {};
+      VULKAN_HPP_NAMESPACE::DisplayKHR                                            m_display        = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher     = nullptr;
     };
 
     class DisplayKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>
@@ -6653,11 +6483,11 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &             display,
         VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const &                          createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_display( &display ), m_dispatcher( display.getDispatcher() )
+        : m_physicalDevice( display.getPhysicalDevice() ), m_dispatcher( display.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( display.getDispatcher()->vkCreateDisplayModeKHR(
-            static_cast<VkPhysicalDevice>( **display.getPhysicalDevice() ),
+            static_cast<VkPhysicalDevice>( display.getPhysicalDevice() ),
             static_cast<VkDisplayKHR>( *display ),
             reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
             reinterpret_cast<const VkAllocationCallbacks *>(
@@ -6671,7 +6501,9 @@ namespace VULKAN_HPP_NAMESPACE
 
       DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,
                       VkDisplayModeKHR                                                    displayModeKHR )
-        : m_display( &display ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() )
+        : m_physicalDevice( display.getPhysicalDevice() )
+        , m_displayModeKHR( displayModeKHR )
+        , m_dispatcher( display.getDispatcher() )
       {}
 
       DisplayModeKHR( std::nullptr_t ) {}
@@ -6679,7 +6511,7 @@ namespace VULKAN_HPP_NAMESPACE
       DisplayModeKHR()                         = delete;
       DisplayModeKHR( DisplayModeKHR const & ) = delete;
       DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, nullptr ) )
+        : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
         , m_displayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
@@ -6688,7 +6520,7 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          m_display        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, nullptr );
+          m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
           m_displayModeKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} );
           m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
@@ -6700,11 +6532,6 @@ namespace VULKAN_HPP_NAMESPACE
         return m_displayModeKHR;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const * getDisplayKHR() const VULKAN_HPP_NOEXCEPT
-      {
-        return m_display;
-      }
-
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
       {
         VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -6717,9 +6544,9 @@ namespace VULKAN_HPP_NAMESPACE
                            getDisplayPlaneCapabilities( uint32_t planeIndex ) const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const *         m_display = nullptr;
-      VULKAN_HPP_NAMESPACE::DisplayModeKHR                                        m_displayModeKHR;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::PhysicalDevice                                        m_physicalDevice = {};
+      VULKAN_HPP_NAMESPACE::DisplayModeKHR                                        m_displayModeKHR = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher     = nullptr;
     };
 
     class Event
@@ -6736,15 +6563,14 @@ namespace VULKAN_HPP_NAMESPACE
       Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VULKAN_HPP_NAMESPACE::EventCreateInfo const &                                   createInfo,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateEvent( static_cast<VkDevice>( *device ),
                                                  reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
-                                                 m_allocator,
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                  reinterpret_cast<VkEvent *>( &m_event ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -6755,10 +6581,9 @@ namespace VULKAN_HPP_NAMESPACE
       Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VkEvent                                                                         event,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_event( event )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -6768,17 +6593,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_event )
         {
-          getDispatcher()->vkDestroyEvent(
-            static_cast<VkDevice>( **m_device ), static_cast<VkEvent>( m_event ), m_allocator );
+          getDispatcher()->vkDestroyEvent( static_cast<VkDevice>( m_device ),
+                                           static_cast<VkEvent>( m_event ),
+                                           reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Event()                = delete;
       Event( Event const & ) = delete;
       Event( Event && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Event & operator=( Event const & ) = delete;
@@ -6786,14 +6612,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_event )
-          {
-            getDispatcher()->vkDestroyEvent(
-              static_cast<VkDevice>( **m_device ), static_cast<VkEvent>( m_event ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_event      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -6804,7 +6625,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_event;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -6824,9 +6645,9 @@ namespace VULKAN_HPP_NAMESPACE
       void reset() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Event                                               m_event;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::Event                                               m_event      = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -6844,15 +6665,14 @@ namespace VULKAN_HPP_NAMESPACE
       Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VULKAN_HPP_NAMESPACE::FenceCreateInfo const &                                   createInfo,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateFence( static_cast<VkDevice>( *device ),
                                                  reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
-                                                 m_allocator,
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                  reinterpret_cast<VkFence *>( &m_fence ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -6863,16 +6683,15 @@ namespace VULKAN_HPP_NAMESPACE
       Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const &                                deviceEventInfo,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkRegisterDeviceEventEXT(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkFence *>( &m_fence ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -6884,9 +6703,8 @@ namespace VULKAN_HPP_NAMESPACE
              VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &             display,
              VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const &                               displayEventInfo,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
@@ -6894,7 +6712,7 @@ namespace VULKAN_HPP_NAMESPACE
             static_cast<VkDevice>( *device ),
             static_cast<VkDisplayKHR>( *display ),
             reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkFence *>( &m_fence ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -6905,10 +6723,9 @@ namespace VULKAN_HPP_NAMESPACE
       Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VkFence                                                                         fence,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_fence( fence )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -6918,17 +6735,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_fence )
         {
-          getDispatcher()->vkDestroyFence(
-            static_cast<VkDevice>( **m_device ), static_cast<VkFence>( m_fence ), m_allocator );
+          getDispatcher()->vkDestroyFence( static_cast<VkDevice>( m_device ),
+                                           static_cast<VkFence>( m_fence ),
+                                           reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Fence()                = delete;
       Fence( Fence const & ) = delete;
       Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Fence & operator=( Fence const & ) = delete;
@@ -6936,14 +6754,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_fence )
-          {
-            getDispatcher()->vkDestroyFence(
-              static_cast<VkDevice>( **m_device ), static_cast<VkFence>( m_fence ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_fence      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -6954,7 +6767,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_fence;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -6970,9 +6783,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Fence                                               m_fence;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::Fence                                               m_fence      = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -6990,15 +6803,14 @@ namespace VULKAN_HPP_NAMESPACE
       Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const &                             createInfo,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateFramebuffer( static_cast<VkDevice>( *device ),
                                                        reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
-                                                       m_allocator,
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                        reinterpret_cast<VkFramebuffer *>( &m_framebuffer ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -7009,10 +6821,9 @@ namespace VULKAN_HPP_NAMESPACE
       Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VkFramebuffer                                                                   framebuffer,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_framebuffer( framebuffer )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -7022,17 +6833,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_framebuffer )
         {
-          getDispatcher()->vkDestroyFramebuffer(
-            static_cast<VkDevice>( **m_device ), static_cast<VkFramebuffer>( m_framebuffer ), m_allocator );
+          getDispatcher()->vkDestroyFramebuffer( static_cast<VkDevice>( m_device ),
+                                                 static_cast<VkFramebuffer>( m_framebuffer ),
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Framebuffer()                      = delete;
       Framebuffer( Framebuffer const & ) = delete;
       Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Framebuffer & operator=( Framebuffer const & ) = delete;
@@ -7040,14 +6852,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_framebuffer )
-          {
-            getDispatcher()->vkDestroyFramebuffer(
-              static_cast<VkDevice>( **m_device ), static_cast<VkFramebuffer>( m_framebuffer ), m_allocator );
-          }
-          m_device      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_framebuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} );
-          m_allocator   = rhs.m_allocator;
+          m_allocator   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -7058,7 +6865,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_framebuffer;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -7070,10 +6877,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Framebuffer                                         m_framebuffer;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device      = {};
+      VULKAN_HPP_NAMESPACE::Framebuffer                                         m_framebuffer = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator   = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher  = nullptr;
     };
 
     class Image
@@ -7090,15 +6897,14 @@ namespace VULKAN_HPP_NAMESPACE
       Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VULKAN_HPP_NAMESPACE::ImageCreateInfo const &                                   createInfo,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateImage( static_cast<VkDevice>( *device ),
                                                  reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
-                                                 m_allocator,
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                  reinterpret_cast<VkImage *>( &m_image ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -7109,10 +6915,9 @@ namespace VULKAN_HPP_NAMESPACE
       Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VkImage                                                                         image,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_image( image )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -7122,17 +6927,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_image )
         {
-          getDispatcher()->vkDestroyImage(
-            static_cast<VkDevice>( **m_device ), static_cast<VkImage>( m_image ), m_allocator );
+          getDispatcher()->vkDestroyImage( static_cast<VkDevice>( m_device ),
+                                           static_cast<VkImage>( m_image ),
+                                           reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Image()                = delete;
       Image( Image const & ) = delete;
       Image( Image && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Image & operator=( Image const & ) = delete;
@@ -7140,14 +6946,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_image )
-          {
-            getDispatcher()->vkDestroyImage(
-              static_cast<VkDevice>( **m_device ), static_cast<VkImage>( m_image ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_image      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -7158,7 +6959,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_image;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -7187,9 +6988,9 @@ namespace VULKAN_HPP_NAMESPACE
                            getDrmFormatModifierPropertiesEXT() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Image                                               m_image;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::Image                                               m_image      = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -7207,15 +7008,14 @@ namespace VULKAN_HPP_NAMESPACE
       ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const &                               createInfo,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateImageView( static_cast<VkDevice>( *device ),
                                                      reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
-                                                     m_allocator,
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                      reinterpret_cast<VkImageView *>( &m_imageView ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -7226,10 +7026,9 @@ namespace VULKAN_HPP_NAMESPACE
       ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VkImageView                                                                     imageView,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_imageView( imageView )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -7239,17 +7038,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_imageView )
         {
-          getDispatcher()->vkDestroyImageView(
-            static_cast<VkDevice>( **m_device ), static_cast<VkImageView>( m_imageView ), m_allocator );
+          getDispatcher()->vkDestroyImageView( static_cast<VkDevice>( m_device ),
+                                               static_cast<VkImageView>( m_imageView ),
+                                               reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       ImageView()                    = delete;
       ImageView( ImageView const & ) = delete;
       ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_imageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       ImageView & operator=( ImageView const & ) = delete;
@@ -7257,14 +7057,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_imageView )
-          {
-            getDispatcher()->vkDestroyImageView(
-              static_cast<VkDevice>( **m_device ), static_cast<VkImageView>( m_imageView ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_imageView  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -7275,7 +7070,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_imageView;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -7291,9 +7086,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::ImageView                                           m_imageView;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::ImageView                                           m_imageView  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -7312,17 +7107,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &                createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateIndirectCommandsLayoutNV(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkIndirectCommandsLayoutNV *>( &m_indirectCommandsLayoutNV ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkIndirectCommandsLayoutNV *>( &m_indirectCommandsLayout ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateIndirectCommandsLayoutNV" );
@@ -7331,12 +7125,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       IndirectCommandsLayoutNV(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkIndirectCommandsLayoutNV                                                      indirectCommandsLayoutNV,
+        VkIndirectCommandsLayoutNV                                                      indirectCommandsLayout,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_indirectCommandsLayout( indirectCommandsLayout )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -7344,22 +7137,22 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~IndirectCommandsLayoutNV()
       {
-        if ( m_indirectCommandsLayoutNV )
+        if ( m_indirectCommandsLayout )
         {
           getDispatcher()->vkDestroyIndirectCommandsLayoutNV(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayoutNV ),
-            m_allocator );
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayout ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       IndirectCommandsLayoutNV()                                   = delete;
       IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & ) = delete;
       IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_indirectCommandsLayoutNV(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_indirectCommandsLayout(
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete;
@@ -7367,17 +7160,10 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_indirectCommandsLayoutNV )
-          {
-            getDispatcher()->vkDestroyIndirectCommandsLayoutNV(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayoutNV ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_indirectCommandsLayoutNV =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} );
-          m_allocator  = rhs.m_allocator;
+          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_indirectCommandsLayout =
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -7385,10 +7171,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_indirectCommandsLayoutNV;
+        return m_indirectCommandsLayout;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -7400,10 +7186,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                            m_indirectCommandsLayoutNV;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device                 = {};
+      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                            m_indirectCommandsLayout = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator              = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher             = nullptr;
     };
 
     class PerformanceConfigurationINTEL
@@ -7420,13 +7206,13 @@ namespace VULKAN_HPP_NAMESPACE
       PerformanceConfigurationINTEL(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &        device,
         VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo )
-        : m_device( &device ), m_dispatcher( device.getDispatcher() )
+        : m_device( *device ), m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkAcquirePerformanceConfigurationINTEL(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
-            reinterpret_cast<VkPerformanceConfigurationINTEL *>( &m_performanceConfigurationINTEL ) ) );
+            reinterpret_cast<VkPerformanceConfigurationINTEL *>( &m_configuration ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkAcquirePerformanceConfigurationINTEL" );
@@ -7434,30 +7220,26 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
       PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
-                                     VkPerformanceConfigurationINTEL performanceConfigurationINTEL )
-        : m_device( &device )
-        , m_performanceConfigurationINTEL( performanceConfigurationINTEL )
-        , m_dispatcher( device.getDispatcher() )
+                                     VkPerformanceConfigurationINTEL                                 configuration )
+        : m_device( *device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() )
       {}
 
       PerformanceConfigurationINTEL( std::nullptr_t ) {}
 
       ~PerformanceConfigurationINTEL()
       {
-        if ( m_performanceConfigurationINTEL )
+        if ( m_configuration )
         {
           getDispatcher()->vkReleasePerformanceConfigurationINTEL(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkPerformanceConfigurationINTEL>( m_performanceConfigurationINTEL ) );
+            static_cast<VkDevice>( m_device ), static_cast<VkPerformanceConfigurationINTEL>( m_configuration ) );
         }
       }
 
       PerformanceConfigurationINTEL()                                        = delete;
       PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & ) = delete;
       PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_performanceConfigurationINTEL(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_configuration( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete;
@@ -7465,26 +7247,19 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_performanceConfigurationINTEL )
-          {
-            getDispatcher()->vkReleasePerformanceConfigurationINTEL(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkPerformanceConfigurationINTEL>( m_performanceConfigurationINTEL ) );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_performanceConfigurationINTEL =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} );
-          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_configuration = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} );
+          m_dispatcher    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_performanceConfigurationINTEL;
+        return m_configuration;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -7496,9 +7271,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL                       m_performanceConfigurationINTEL;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device        = {};
+      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL                       m_configuration = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher    = nullptr;
     };
 
     class PipelineCache
@@ -7516,16 +7291,15 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const &                           createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreatePipelineCache(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkPipelineCache *>( &m_pipelineCache ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -7537,10 +7311,9 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VkPipelineCache                                                                 pipelineCache,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_pipelineCache( pipelineCache )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -7550,17 +7323,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_pipelineCache )
         {
-          getDispatcher()->vkDestroyPipelineCache(
-            static_cast<VkDevice>( **m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), m_allocator );
+          getDispatcher()->vkDestroyPipelineCache( static_cast<VkDevice>( m_device ),
+                                                   static_cast<VkPipelineCache>( m_pipelineCache ),
+                                                   reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       PipelineCache()                        = delete;
       PipelineCache( PipelineCache const & ) = delete;
       PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_pipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       PipelineCache & operator=( PipelineCache const & ) = delete;
@@ -7568,14 +7342,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_pipelineCache )
-          {
-            getDispatcher()->vkDestroyPipelineCache(
-              static_cast<VkDevice>( **m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), m_allocator );
-          }
-          m_device        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device        = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_pipelineCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} );
-          m_allocator     = rhs.m_allocator;
+          m_allocator     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -7586,7 +7355,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_pipelineCache;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -7604,10 +7373,10 @@ namespace VULKAN_HPP_NAMESPACE
       void merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::PipelineCache                                       m_pipelineCache;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device        = {};
+      VULKAN_HPP_NAMESPACE::PipelineCache                                       m_pipelineCache = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator     = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher    = nullptr;
     };
 
     class Pipeline
@@ -7627,9 +7396,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                         pipelineCache,
         VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const &                         createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateComputePipelines(
@@ -7637,7 +7405,7 @@ namespace VULKAN_HPP_NAMESPACE
           pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
           1,
           reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
-          m_allocator,
+          reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
           reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
         if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
              ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
@@ -7652,9 +7420,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                         pipelineCache,
         VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const &                        createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         m_constructorSuccessCode =
@@ -7663,7 +7430,7 @@ namespace VULKAN_HPP_NAMESPACE
             pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
             1,
             reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
         if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
              ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
@@ -7680,9 +7447,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                         pipelineCache,
         VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const &                   createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         m_constructorSuccessCode =
@@ -7692,7 +7458,7 @@ namespace VULKAN_HPP_NAMESPACE
             pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
             1,
             reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
         if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
              ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) &&
@@ -7709,9 +7475,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                         pipelineCache,
         VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const &                    createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         m_constructorSuccessCode =
@@ -7720,7 +7485,7 @@ namespace VULKAN_HPP_NAMESPACE
             pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
             1,
             reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
         if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
              ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
@@ -7733,10 +7498,9 @@ namespace VULKAN_HPP_NAMESPACE
                 VkPipeline                                                                      pipeline,
                 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr,
                 VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess )
-        : m_device( &device )
+        : m_device( *device )
         , m_pipeline( pipeline )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_constructorSuccessCode( successCode )
         , m_dispatcher( device.getDispatcher() )
       {}
@@ -7747,17 +7511,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_pipeline )
         {
-          getDispatcher()->vkDestroyPipeline(
-            static_cast<VkDevice>( **m_device ), static_cast<VkPipeline>( m_pipeline ), m_allocator );
+          getDispatcher()->vkDestroyPipeline( static_cast<VkDevice>( m_device ),
+                                              static_cast<VkPipeline>( m_pipeline ),
+                                              reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Pipeline()                   = delete;
       Pipeline( Pipeline const & ) = delete;
       Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Pipeline & operator=( Pipeline const & ) = delete;
@@ -7765,14 +7530,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_pipeline )
-          {
-            getDispatcher()->vkDestroyPipeline(
-              static_cast<VkDevice>( **m_device ), static_cast<VkPipeline>( m_pipeline ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_pipeline   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -7788,7 +7548,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_constructorSuccessCode;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -7838,9 +7598,9 @@ namespace VULKAN_HPP_NAMESPACE
         uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Pipeline                                            m_pipeline;
-      const VkAllocationCallbacks *                                             m_allocator = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device    = {};
+      VULKAN_HPP_NAMESPACE::Pipeline                                            m_pipeline  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator = nullptr;
       VULKAN_HPP_NAMESPACE::Result                                              m_constructorSuccessCode;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
@@ -8007,16 +7767,15 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const &                          createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreatePipelineLayout(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkPipelineLayout *>( &m_pipelineLayout ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -8028,10 +7787,9 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VkPipelineLayout                                                                pipelineLayout,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_pipelineLayout( pipelineLayout )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8041,17 +7799,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_pipelineLayout )
         {
-          getDispatcher()->vkDestroyPipelineLayout(
-            static_cast<VkDevice>( **m_device ), static_cast<VkPipelineLayout>( m_pipelineLayout ), m_allocator );
+          getDispatcher()->vkDestroyPipelineLayout( static_cast<VkDevice>( m_device ),
+                                                    static_cast<VkPipelineLayout>( m_pipelineLayout ),
+                                                    reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       PipelineLayout()                         = delete;
       PipelineLayout( PipelineLayout const & ) = delete;
       PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_pipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       PipelineLayout & operator=( PipelineLayout const & ) = delete;
@@ -8059,14 +7818,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_pipelineLayout )
-          {
-            getDispatcher()->vkDestroyPipelineLayout(
-              static_cast<VkDevice>( **m_device ), static_cast<VkPipelineLayout>( m_pipelineLayout ), m_allocator );
-          }
-          m_device         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_pipelineLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} );
-          m_allocator      = rhs.m_allocator;
+          m_allocator      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -8077,7 +7831,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_pipelineLayout;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8089,10 +7843,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::PipelineLayout                                      m_pipelineLayout;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device         = {};
+      VULKAN_HPP_NAMESPACE::PipelineLayout                                      m_pipelineLayout = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator      = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher     = nullptr;
     };
 
     class PrivateDataSlotEXT
@@ -8110,17 +7864,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const &                      createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreatePrivateDataSlotEXT(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkPrivateDataSlotEXT *>( &m_privateDataSlotEXT ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkPrivateDataSlotEXT *>( &m_privateDataSlot ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreatePrivateDataSlotEXT" );
@@ -8129,12 +7882,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       PrivateDataSlotEXT(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkPrivateDataSlotEXT                                                            privateDataSlotEXT,
+        VkPrivateDataSlotEXT                                                            privateDataSlot,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_privateDataSlotEXT( privateDataSlotEXT )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_privateDataSlot( privateDataSlot )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8142,21 +7894,21 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~PrivateDataSlotEXT()
       {
-        if ( m_privateDataSlotEXT )
+        if ( m_privateDataSlot )
         {
-          getDispatcher()->vkDestroyPrivateDataSlotEXT( static_cast<VkDevice>( **m_device ),
-                                                        static_cast<VkPrivateDataSlotEXT>( m_privateDataSlotEXT ),
-                                                        m_allocator );
+          getDispatcher()->vkDestroyPrivateDataSlotEXT(
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkPrivateDataSlotEXT>( m_privateDataSlot ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       PrivateDataSlotEXT()                             = delete;
       PrivateDataSlotEXT( PrivateDataSlotEXT const & ) = delete;
       PrivateDataSlotEXT( PrivateDataSlotEXT && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_privateDataSlotEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlotEXT,
-                                                                                           {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_privateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       PrivateDataSlotEXT & operator=( PrivateDataSlotEXT const & ) = delete;
@@ -8164,27 +7916,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_privateDataSlotEXT )
-          {
-            getDispatcher()->vkDestroyPrivateDataSlotEXT( static_cast<VkDevice>( **m_device ),
-                                                          static_cast<VkPrivateDataSlotEXT>( m_privateDataSlotEXT ),
-                                                          m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_privateDataSlotEXT =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlotEXT, {} );
-          m_allocator  = rhs.m_allocator;
-          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device          = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_privateDataSlot = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} );
+          m_allocator       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_privateDataSlotEXT;
+        return m_privateDataSlot;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8196,10 +7941,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT                                  m_privateDataSlotEXT;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device          = {};
+      VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT                                  m_privateDataSlot = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher      = nullptr;
     };
 
     class QueryPool
@@ -8216,15 +7961,14 @@ namespace VULKAN_HPP_NAMESPACE
       QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const &                               createInfo,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateQueryPool( static_cast<VkDevice>( *device ),
                                                      reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
-                                                     m_allocator,
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                      reinterpret_cast<VkQueryPool *>( &m_queryPool ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -8235,10 +7979,9 @@ namespace VULKAN_HPP_NAMESPACE
       QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VkQueryPool                                                                     queryPool,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_queryPool( queryPool )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8248,17 +7991,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_queryPool )
         {
-          getDispatcher()->vkDestroyQueryPool(
-            static_cast<VkDevice>( **m_device ), static_cast<VkQueryPool>( m_queryPool ), m_allocator );
+          getDispatcher()->vkDestroyQueryPool( static_cast<VkDevice>( m_device ),
+                                               static_cast<VkQueryPool>( m_queryPool ),
+                                               reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       QueryPool()                    = delete;
       QueryPool( QueryPool const & ) = delete;
       QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_queryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       QueryPool & operator=( QueryPool const & ) = delete;
@@ -8266,14 +8010,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_queryPool )
-          {
-            getDispatcher()->vkDestroyQueryPool(
-              static_cast<VkDevice>( **m_device ), static_cast<VkQueryPool>( m_queryPool ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_queryPool  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -8284,7 +8023,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_queryPool;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8321,9 +8060,9 @@ namespace VULKAN_HPP_NAMESPACE
       void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::QueryPool                                           m_queryPool;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::QueryPool                                           m_queryPool  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -8341,7 +8080,7 @@ namespace VULKAN_HPP_NAMESPACE
       Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
              uint32_t                                                        queueFamilyIndex,
              uint32_t                                                        queueIndex )
-        : m_device( &device ), m_dispatcher( device.getDispatcher() )
+        : m_dispatcher( device.getDispatcher() )
       {
         getDispatcher()->vkGetDeviceQueue(
           static_cast<VkDevice>( *device ), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &m_queue ) );
@@ -8349,7 +8088,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
              VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const &                  queueInfo )
-        : m_device( &device ), m_dispatcher( device.getDispatcher() )
+        : m_dispatcher( device.getDispatcher() )
       {
         getDispatcher()->vkGetDeviceQueue2( static_cast<VkDevice>( *device ),
                                             reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ),
@@ -8357,7 +8096,7 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
       Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkQueue queue )
-        : m_device( &device ), m_queue( queue ), m_dispatcher( device.getDispatcher() )
+        : m_queue( queue ), m_dispatcher( device.getDispatcher() )
       {}
 
       Queue( std::nullptr_t ) {}
@@ -8365,8 +8104,7 @@ namespace VULKAN_HPP_NAMESPACE
       Queue()                = delete;
       Queue( Queue const & ) = delete;
       Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) )
+        : m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Queue & operator=( Queue const & ) = delete;
@@ -8374,7 +8112,6 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
           m_queue      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
@@ -8386,11 +8123,6 @@ namespace VULKAN_HPP_NAMESPACE
         return m_queue;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
-      {
-        return m_device;
-      }
-
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
       {
         VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -8440,8 +8172,7 @@ namespace VULKAN_HPP_NAMESPACE
                            getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Queue                                               m_queue;
+      VULKAN_HPP_NAMESPACE::Queue                                               m_queue      = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -8459,15 +8190,14 @@ namespace VULKAN_HPP_NAMESPACE
       RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                   VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const &                              createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateRenderPass( static_cast<VkDevice>( *device ),
                                                       reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
-                                                      m_allocator,
+                                                      reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                       reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -8478,15 +8208,14 @@ namespace VULKAN_HPP_NAMESPACE
       RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                   VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const &                             createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateRenderPass2( static_cast<VkDevice>( *device ),
                                                        reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-                                                       m_allocator,
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                        reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -8497,10 +8226,9 @@ namespace VULKAN_HPP_NAMESPACE
       RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                   VkRenderPass                                                                    renderPass,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_renderPass( renderPass )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8510,17 +8238,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_renderPass )
         {
-          getDispatcher()->vkDestroyRenderPass(
-            static_cast<VkDevice>( **m_device ), static_cast<VkRenderPass>( m_renderPass ), m_allocator );
+          getDispatcher()->vkDestroyRenderPass( static_cast<VkDevice>( m_device ),
+                                                static_cast<VkRenderPass>( m_renderPass ),
+                                                reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       RenderPass()                     = delete;
       RenderPass( RenderPass const & ) = delete;
       RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_renderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       RenderPass & operator=( RenderPass const & ) = delete;
@@ -8528,14 +8257,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_renderPass )
-          {
-            getDispatcher()->vkDestroyRenderPass(
-              static_cast<VkDevice>( **m_device ), static_cast<VkRenderPass>( m_renderPass ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_renderPass = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -8546,7 +8270,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_renderPass;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8567,9 +8291,9 @@ namespace VULKAN_HPP_NAMESPACE
                            getSubpassShadingMaxWorkgroupSizeHUAWEI() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::RenderPass                                          m_renderPass;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::RenderPass                                          m_renderPass = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -8587,15 +8311,14 @@ namespace VULKAN_HPP_NAMESPACE
       Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                VULKAN_HPP_NAMESPACE::SamplerCreateInfo const &                                 createInfo,
                VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateSampler( static_cast<VkDevice>( *device ),
                                                    reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
-                                                   m_allocator,
+                                                   reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                    reinterpret_cast<VkSampler *>( &m_sampler ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -8606,10 +8329,9 @@ namespace VULKAN_HPP_NAMESPACE
       Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                VkSampler                                                                       sampler,
                VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_sampler( sampler )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8619,17 +8341,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_sampler )
         {
-          getDispatcher()->vkDestroySampler(
-            static_cast<VkDevice>( **m_device ), static_cast<VkSampler>( m_sampler ), m_allocator );
+          getDispatcher()->vkDestroySampler( static_cast<VkDevice>( m_device ),
+                                             static_cast<VkSampler>( m_sampler ),
+                                             reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Sampler()                  = delete;
       Sampler( Sampler const & ) = delete;
       Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Sampler & operator=( Sampler const & ) = delete;
@@ -8637,14 +8360,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_sampler )
-          {
-            getDispatcher()->vkDestroySampler(
-              static_cast<VkDevice>( **m_device ), static_cast<VkSampler>( m_sampler ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_sampler    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -8655,7 +8373,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_sampler;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8667,9 +8385,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Sampler                                             m_sampler;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::Sampler                                             m_sampler    = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -8688,17 +8406,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const &                  createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateSamplerYcbcrConversion(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSamplerYcbcrConversion *>( &m_samplerYcbcrConversion ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSamplerYcbcrConversion *>( &m_ycbcrConversion ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateSamplerYcbcrConversion" );
@@ -8707,12 +8424,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       SamplerYcbcrConversion(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkSamplerYcbcrConversion                                                        samplerYcbcrConversion,
+        VkSamplerYcbcrConversion                                                        ycbcrConversion,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_samplerYcbcrConversion( samplerYcbcrConversion )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_ycbcrConversion( ycbcrConversion )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8720,22 +8436,21 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~SamplerYcbcrConversion()
       {
-        if ( m_samplerYcbcrConversion )
+        if ( m_ycbcrConversion )
         {
           getDispatcher()->vkDestroySamplerYcbcrConversion(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkSamplerYcbcrConversion>( m_samplerYcbcrConversion ),
-            m_allocator );
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkSamplerYcbcrConversion>( m_ycbcrConversion ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       SamplerYcbcrConversion()                                 = delete;
       SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete;
       SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_samplerYcbcrConversion(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete;
@@ -8743,28 +8458,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_samplerYcbcrConversion )
-          {
-            getDispatcher()->vkDestroySamplerYcbcrConversion(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkSamplerYcbcrConversion>( m_samplerYcbcrConversion ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_samplerYcbcrConversion =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} );
-          m_allocator  = rhs.m_allocator;
-          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device          = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_ycbcrConversion = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} );
+          m_allocator       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_samplerYcbcrConversion;
+        return m_ycbcrConversion;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8776,10 +8483,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion                              m_samplerYcbcrConversion;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device          = {};
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion                              m_ycbcrConversion = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher      = nullptr;
     };
 
     class Semaphore
@@ -8796,15 +8503,14 @@ namespace VULKAN_HPP_NAMESPACE
       Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const &                               createInfo,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
           device.getDispatcher()->vkCreateSemaphore( static_cast<VkDevice>( *device ),
                                                      reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
-                                                     m_allocator,
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
                                                      reinterpret_cast<VkSemaphore *>( &m_semaphore ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -8815,10 +8521,9 @@ namespace VULKAN_HPP_NAMESPACE
       Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VkSemaphore                                                                     semaphore,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_semaphore( semaphore )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8828,17 +8533,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_semaphore )
         {
-          getDispatcher()->vkDestroySemaphore(
-            static_cast<VkDevice>( **m_device ), static_cast<VkSemaphore>( m_semaphore ), m_allocator );
+          getDispatcher()->vkDestroySemaphore( static_cast<VkDevice>( m_device ),
+                                               static_cast<VkSemaphore>( m_semaphore ),
+                                               reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       Semaphore()                    = delete;
       Semaphore( Semaphore const & ) = delete;
       Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       Semaphore & operator=( Semaphore const & ) = delete;
@@ -8846,14 +8552,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_semaphore )
-          {
-            getDispatcher()->vkDestroySemaphore(
-              static_cast<VkDevice>( **m_device ), static_cast<VkSemaphore>( m_semaphore ), m_allocator );
-          }
-          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_semaphore  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} );
-          m_allocator  = rhs.m_allocator;
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -8864,7 +8565,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_semaphore;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8884,9 +8585,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::Semaphore                                           m_semaphore;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::Semaphore                                           m_semaphore  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -8905,16 +8606,15 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const &                            createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateShaderModule(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
-            m_allocator,
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
             reinterpret_cast<VkShaderModule *>( &m_shaderModule ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
@@ -8926,10 +8626,9 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VkShaderModule                                                                  shaderModule,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
+        : m_device( *device )
         , m_shaderModule( shaderModule )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -8939,17 +8638,18 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( m_shaderModule )
         {
-          getDispatcher()->vkDestroyShaderModule(
-            static_cast<VkDevice>( **m_device ), static_cast<VkShaderModule>( m_shaderModule ), m_allocator );
+          getDispatcher()->vkDestroyShaderModule( static_cast<VkDevice>( m_device ),
+                                                  static_cast<VkShaderModule>( m_shaderModule ),
+                                                  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       ShaderModule()                       = delete;
       ShaderModule( ShaderModule const & ) = delete;
       ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
         , m_shaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ) )
-        , m_allocator( rhs.m_allocator )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       ShaderModule & operator=( ShaderModule const & ) = delete;
@@ -8957,14 +8657,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_shaderModule )
-          {
-            getDispatcher()->vkDestroyShaderModule(
-              static_cast<VkDevice>( **m_device ), static_cast<VkShaderModule>( m_shaderModule ), m_allocator );
-          }
-          m_device       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
+          m_device       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
           m_shaderModule = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} );
-          m_allocator    = rhs.m_allocator;
+          m_allocator    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -8975,7 +8670,7 @@ namespace VULKAN_HPP_NAMESPACE
         return m_shaderModule;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -8987,10 +8682,10 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::ShaderModule                                        m_shaderModule;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device       = {};
+      VULKAN_HPP_NAMESPACE::ShaderModule                                        m_shaderModule = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator    = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher   = nullptr;
     };
 
     class SurfaceKHR
@@ -9008,17 +8703,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const &                       createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateAndroidSurfaceKHR(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateAndroidSurfaceKHR" );
@@ -9030,17 +8724,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const &                      createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDirectFBSurfaceEXT(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateDirectFBSurfaceEXT" );
@@ -9051,17 +8744,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const &                       createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDisplayPlaneSurfaceKHR(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" );
@@ -9071,17 +8763,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const &                      createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateHeadlessSurfaceEXT(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateHeadlessSurfaceEXT" );
@@ -9092,17 +8783,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const &                           createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateIOSSurfaceMVK(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateIOSSurfaceMVK" );
@@ -9114,17 +8804,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &                 createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateImagePipeSurfaceFUCHSIA" );
@@ -9136,17 +8825,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const &                         createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateMacOSSurfaceMVK(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateMacOSSurfaceMVK" );
@@ -9158,17 +8846,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const &                         createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateMetalSurfaceEXT(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateMetalSurfaceEXT" );
@@ -9180,17 +8867,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const &                        createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateScreenSurfaceQNX(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateScreenSurfaceQNX" );
@@ -9202,17 +8888,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &              createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateStreamDescriptorSurfaceGGP(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateStreamDescriptorSurfaceGGP" );
@@ -9224,17 +8909,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const &                             createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateViSurfaceNN(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateViSurfaceNN" );
@@ -9246,17 +8930,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const &                       createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateWaylandSurfaceKHR(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateWaylandSurfaceKHR" );
@@ -9268,17 +8951,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const &                         createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateWin32SurfaceKHR(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateWin32SurfaceKHR" );
@@ -9290,17 +8972,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const &                           createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateXcbSurfaceKHR(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateXcbSurfaceKHR" );
@@ -9312,17 +8993,16 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const &                          createInfo,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateXlibSurfaceKHR(
             static_cast<VkInstance>( *instance ),
             reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSurfaceKHR *>( &m_surfaceKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateXlibSurfaceKHR" );
@@ -9331,12 +9011,11 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
-                  VkSurfaceKHR                                                                    surfaceKHR,
+                  VkSurfaceKHR                                                                    surface,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( &instance )
-        , m_surfaceKHR( surfaceKHR )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_instance( *instance )
+        , m_surface( surface )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
       {}
 
@@ -9344,19 +9023,20 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~SurfaceKHR()
       {
-        if ( m_surfaceKHR )
+        if ( m_surface )
         {
-          getDispatcher()->vkDestroySurfaceKHR(
-            static_cast<VkInstance>( **m_instance ), static_cast<VkSurfaceKHR>( m_surfaceKHR ), m_allocator );
+          getDispatcher()->vkDestroySurfaceKHR( static_cast<VkInstance>( m_instance ),
+                                                static_cast<VkSurfaceKHR>( m_surface ),
+                                                reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       SurfaceKHR()                     = delete;
       SurfaceKHR( SurfaceKHR const & ) = delete;
       SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) )
-        , m_surfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
+        , m_surface( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       SurfaceKHR & operator=( SurfaceKHR const & ) = delete;
@@ -9364,14 +9044,9 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_surfaceKHR )
-          {
-            getDispatcher()->vkDestroySurfaceKHR(
-              static_cast<VkInstance>( **m_instance ), static_cast<VkSurfaceKHR>( m_surfaceKHR ), m_allocator );
-          }
-          m_instance   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr );
-          m_surfaceKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surfaceKHR, {} );
-          m_allocator  = rhs.m_allocator;
+          m_instance   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
+          m_surface    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -9379,10 +9054,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_surfaceKHR;
+        return m_surface;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Instance getInstance() const
       {
         return m_instance;
       }
@@ -9394,9 +9069,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const *           m_instance = nullptr;
-      VULKAN_HPP_NAMESPACE::SurfaceKHR                                            m_surfaceKHR;
-      const VkAllocationCallbacks *                                               m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Instance                                              m_instance   = {};
+      VULKAN_HPP_NAMESPACE::SurfaceKHR                                            m_surface    = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -9415,17 +9090,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const &                            createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateSwapchainKHR(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkSwapchainKHR *>( &m_swapchainKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkSwapchainKHR *>( &m_swapchain ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateSwapchainKHR" );
@@ -9434,12 +9108,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       SwapchainKHR(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkSwapchainKHR                                                                  swapchainKHR,
+        VkSwapchainKHR                                                                  swapchain,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_swapchainKHR( swapchainKHR )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_swapchain( swapchain )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -9447,19 +9120,20 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~SwapchainKHR()
       {
-        if ( m_swapchainKHR )
+        if ( m_swapchain )
         {
-          getDispatcher()->vkDestroySwapchainKHR(
-            static_cast<VkDevice>( **m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ), m_allocator );
+          getDispatcher()->vkDestroySwapchainKHR( static_cast<VkDevice>( m_device ),
+                                                  static_cast<VkSwapchainKHR>( m_swapchain ),
+                                                  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       SwapchainKHR()                       = delete;
       SwapchainKHR( SwapchainKHR const & ) = delete;
       SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_swapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_swapchain( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       SwapchainKHR & operator=( SwapchainKHR const & ) = delete;
@@ -9467,25 +9141,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_swapchainKHR )
-          {
-            getDispatcher()->vkDestroySwapchainKHR(
-              static_cast<VkDevice>( **m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ), m_allocator );
-          }
-          m_device       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_swapchainKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchainKHR, {} );
-          m_allocator    = rhs.m_allocator;
-          m_dispatcher   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_swapchain  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_swapchainKHR;
+        return m_swapchain;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -9537,9 +9206,9 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::SwapchainKHR                                        m_swapchainKHR;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
+      VULKAN_HPP_NAMESPACE::SwapchainKHR                                        m_swapchain  = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -9597,17 +9266,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const &                      createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateValidationCacheEXT(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkValidationCacheEXT *>( &m_validationCacheEXT ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkValidationCacheEXT *>( &m_validationCache ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateValidationCacheEXT" );
@@ -9616,12 +9284,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       ValidationCacheEXT(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkValidationCacheEXT                                                            validationCacheEXT,
+        VkValidationCacheEXT                                                            validationCache,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_validationCacheEXT( validationCacheEXT )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_validationCache( validationCache )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -9629,21 +9296,21 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~ValidationCacheEXT()
       {
-        if ( m_validationCacheEXT )
+        if ( m_validationCache )
         {
-          getDispatcher()->vkDestroyValidationCacheEXT( static_cast<VkDevice>( **m_device ),
-                                                        static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
-                                                        m_allocator );
+          getDispatcher()->vkDestroyValidationCacheEXT(
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkValidationCacheEXT>( m_validationCache ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       ValidationCacheEXT()                             = delete;
       ValidationCacheEXT( ValidationCacheEXT const & ) = delete;
       ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_validationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCacheEXT,
-                                                                                           {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_validationCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete;
@@ -9651,27 +9318,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_validationCacheEXT )
-          {
-            getDispatcher()->vkDestroyValidationCacheEXT( static_cast<VkDevice>( **m_device ),
-                                                          static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
-                                                          m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_validationCacheEXT =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} );
-          m_allocator  = rhs.m_allocator;
-          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device          = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_validationCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} );
+          m_allocator       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_validationCacheEXT;
+        return m_validationCache;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -9689,10 +9349,10 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                  m_validationCacheEXT;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device          = {};
+      VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                  m_validationCache = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher      = nullptr;
     };
 
 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -9711,17 +9371,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const &                         createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateVideoSessionKHR(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkVideoSessionKHR *>( &m_videoSessionKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkVideoSessionKHR *>( &m_videoSession ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateVideoSessionKHR" );
@@ -9730,12 +9389,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       VideoSessionKHR(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkVideoSessionKHR                                                               videoSessionKHR,
+        VkVideoSessionKHR                                                               videoSession,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_videoSessionKHR( videoSessionKHR )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_videoSession( videoSession )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -9743,19 +9401,20 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~VideoSessionKHR()
       {
-        if ( m_videoSessionKHR )
+        if ( m_videoSession )
         {
-          getDispatcher()->vkDestroyVideoSessionKHR(
-            static_cast<VkDevice>( **m_device ), static_cast<VkVideoSessionKHR>( m_videoSessionKHR ), m_allocator );
+          getDispatcher()->vkDestroyVideoSessionKHR( static_cast<VkDevice>( m_device ),
+                                                     static_cast<VkVideoSessionKHR>( m_videoSession ),
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       VideoSessionKHR()                          = delete;
       VideoSessionKHR( VideoSessionKHR const & ) = delete;
       VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_videoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_videoSession( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete;
@@ -9763,25 +9422,20 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_videoSessionKHR )
-          {
-            getDispatcher()->vkDestroyVideoSessionKHR(
-              static_cast<VkDevice>( **m_device ), static_cast<VkVideoSessionKHR>( m_videoSessionKHR ), m_allocator );
-          }
-          m_device          = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_videoSessionKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} );
-          m_allocator       = rhs.m_allocator;
-          m_dispatcher      = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
+          m_device       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_videoSession = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} );
+          m_allocator    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
+          m_dispatcher   = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
 
       VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_videoSessionKHR;
+        return m_videoSession;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -9800,10 +9454,10 @@ namespace VULKAN_HPP_NAMESPACE
         bindMemory( ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories ) const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR                                     m_videoSessionKHR;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device       = {};
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR                                     m_videoSession = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator    = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher   = nullptr;
     };
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
@@ -9823,17 +9477,16 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
         VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &               createInfo,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {
         VULKAN_HPP_NAMESPACE::Result result =
           static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateVideoSessionParametersKHR(
             static_cast<VkDevice>( *device ),
             reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
-            m_allocator,
-            reinterpret_cast<VkVideoSessionParametersKHR *>( &m_videoSessionParametersKHR ) ) );
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
+            reinterpret_cast<VkVideoSessionParametersKHR *>( &m_videoSessionParameters ) ) );
         if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
         {
           throwResultException( result, "vkCreateVideoSessionParametersKHR" );
@@ -9842,12 +9495,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       VideoSessionParametersKHR(
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
-        VkVideoSessionParametersKHR                                                     videoSessionParametersKHR,
+        VkVideoSessionParametersKHR                                                     videoSessionParameters,
         VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( &device )
-        , m_videoSessionParametersKHR( videoSessionParametersKHR )
-        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
-            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        : m_device( *device )
+        , m_videoSessionParameters( videoSessionParameters )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
       {}
 
@@ -9855,22 +9507,22 @@ namespace VULKAN_HPP_NAMESPACE
 
       ~VideoSessionParametersKHR()
       {
-        if ( m_videoSessionParametersKHR )
+        if ( m_videoSessionParameters )
         {
           getDispatcher()->vkDestroyVideoSessionParametersKHR(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkVideoSessionParametersKHR>( m_videoSessionParametersKHR ),
-            m_allocator );
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
+            reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
         }
       }
 
       VideoSessionParametersKHR()                                    = delete;
       VideoSessionParametersKHR( VideoSessionParametersKHR const & ) = delete;
       VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
-        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) )
-        , m_videoSessionParametersKHR(
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} ) )
-        , m_allocator( rhs.m_allocator )
+        : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
+        , m_videoSessionParameters(
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ) )
+        , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
         , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete;
@@ -9878,17 +9530,10 @@ namespace VULKAN_HPP_NAMESPACE
       {
         if ( this != &rhs )
         {
-          if ( m_videoSessionParametersKHR )
-          {
-            getDispatcher()->vkDestroyVideoSessionParametersKHR(
-              static_cast<VkDevice>( **m_device ),
-              static_cast<VkVideoSessionParametersKHR>( m_videoSessionParametersKHR ),
-              m_allocator );
-          }
-          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr );
-          m_videoSessionParametersKHR =
-            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} );
-          m_allocator  = rhs.m_allocator;
+          m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
+          m_videoSessionParameters =
+            VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} );
+          m_allocator  = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
           m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
@@ -9896,10 +9541,10 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
-        return m_videoSessionParametersKHR;
+        return m_videoSessionParameters;
       }
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::Device getDevice() const
       {
         return m_device;
       }
@@ -9915,10 +9560,10 @@ namespace VULKAN_HPP_NAMESPACE
       void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const;
 
     private:
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const *           m_device = nullptr;
-      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                           m_videoSessionParametersKHR;
-      const VkAllocationCallbacks *                                             m_allocator  = nullptr;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
+      VULKAN_HPP_NAMESPACE::Device                                              m_device                 = {};
+      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                           m_videoSessionParameters = {};
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator              = nullptr;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher             = nullptr;
     };
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
@@ -10219,8 +9864,8 @@ namespace VULKAN_HPP_NAMESPACE
     {
       void *                       pData;
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkMapMemory( static_cast<VkDevice>( **m_device ),
-                                      static_cast<VkDeviceMemory>( m_deviceMemory ),
+        getDispatcher()->vkMapMemory( static_cast<VkDevice>( m_device ),
+                                      static_cast<VkDeviceMemory>( m_memory ),
                                       static_cast<VkDeviceSize>( offset ),
                                       static_cast<VkDeviceSize>( size ),
                                       static_cast<VkMemoryMapFlags>( flags ),
@@ -10234,8 +9879,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT
     {
-      getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( **m_device ),
-                                      static_cast<VkDeviceMemory>( m_deviceMemory ) );
+      getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ) );
     }
 
     VULKAN_HPP_INLINE void Device::flushMappedMemoryRanges(
@@ -10270,8 +9914,8 @@ namespace VULKAN_HPP_NAMESPACE
                                            DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
-      getDispatcher()->vkGetDeviceMemoryCommitment( static_cast<VkDevice>( **m_device ),
-                                                    static_cast<VkDeviceMemory>( m_deviceMemory ),
+      getDispatcher()->vkGetDeviceMemoryCommitment( static_cast<VkDevice>( m_device ),
+                                                    static_cast<VkDeviceMemory>( m_memory ),
                                                     reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
       return committedMemoryInBytes;
     }
@@ -10280,7 +9924,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset ) const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( m_device ),
                                              static_cast<VkBuffer>( m_buffer ),
                                              static_cast<VkDeviceMemory>( memory ),
                                              static_cast<VkDeviceSize>( memoryOffset ) ) );
@@ -10294,7 +9938,7 @@ namespace VULKAN_HPP_NAMESPACE
                                               VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset ) const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBindImageMemory( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkBindImageMemory( static_cast<VkDevice>( m_device ),
                                             static_cast<VkImage>( m_image ),
                                             static_cast<VkDeviceMemory>( memory ),
                                             static_cast<VkDeviceSize>( memoryOffset ) ) );
@@ -10308,7 +9952,7 @@ namespace VULKAN_HPP_NAMESPACE
                                            Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
-      getDispatcher()->vkGetBufferMemoryRequirements( static_cast<VkDevice>( **m_device ),
+      getDispatcher()->vkGetBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
                                                       static_cast<VkBuffer>( m_buffer ),
                                                       reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
       return memoryRequirements;
@@ -10318,7 +9962,7 @@ namespace VULKAN_HPP_NAMESPACE
                                            Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
-      getDispatcher()->vkGetImageMemoryRequirements( static_cast<VkDevice>( **m_device ),
+      getDispatcher()->vkGetImageMemoryRequirements( static_cast<VkDevice>( m_device ),
                                                      static_cast<VkImage>( m_image ),
                                                      reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
       return memoryRequirements;
@@ -10329,11 +9973,11 @@ namespace VULKAN_HPP_NAMESPACE
     {
       uint32_t sparseMemoryRequirementCount;
       getDispatcher()->vkGetImageSparseMemoryRequirements(
-        static_cast<VkDevice>( **m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr );
+        static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr );
       std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements(
         sparseMemoryRequirementCount );
       getDispatcher()->vkGetImageSparseMemoryRequirements(
-        static_cast<VkDevice>( **m_device ),
+        static_cast<VkDevice>( m_device ),
         static_cast<VkImage>( m_image ),
         &sparseMemoryRequirementCount,
         reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
@@ -10407,7 +10051,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Fence::getStatus() const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( **m_device ), static_cast<VkFence>( m_fence ) ) );
+        getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) ) );
       if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
            ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) )
       {
@@ -10452,7 +10096,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( **m_device ), static_cast<VkEvent>( m_event ) ) );
+        getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
       if ( ( result != VULKAN_HPP_NAMESPACE::Result::eEventSet ) &&
            ( result != VULKAN_HPP_NAMESPACE::Result::eEventReset ) )
       {
@@ -10464,7 +10108,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_INLINE void Event::set() const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkSetEvent( static_cast<VkDevice>( **m_device ), static_cast<VkEvent>( m_event ) ) );
+        getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::set" );
@@ -10474,7 +10118,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_INLINE void Event::reset() const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkResetEvent( static_cast<VkDevice>( **m_device ), static_cast<VkEvent>( m_event ) ) );
+        getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset" );
@@ -10499,7 +10143,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
       std::vector<T> data( dataSize / sizeof( T ) );
       Result         result =
-        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( **m_device ),
+        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
                                                                      static_cast<VkQueryPool>( m_queryPool ),
                                                                      firstQuery,
                                                                      queryCount,
@@ -10524,7 +10168,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       T      data;
       Result result =
-        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( **m_device ),
+        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
                                                                      static_cast<VkQueryPool>( m_queryPool ),
                                                                      firstQuery,
                                                                      queryCount,
@@ -10565,7 +10209,7 @@ namespace VULKAN_HPP_NAMESPACE
       const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_NAMESPACE::SubresourceLayout layout;
-      getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( **m_device ),
+      getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ),
                                                     static_cast<VkImage>( m_image ),
                                                     reinterpret_cast<const VkImageSubresource *>( &subresource ),
                                                     reinterpret_cast<VkSubresourceLayout *>( &layout ) );
@@ -10601,12 +10245,12 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineCacheData(
-          static_cast<VkDevice>( **m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr ) );
         if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
         {
           data.resize( dataSize );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( **m_device ),
+            getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ),
                                                      static_cast<VkPipelineCache>( m_pipelineCache ),
                                                      &dataSize,
                                                      reinterpret_cast<void *>( data.data() ) ) );
@@ -10628,7 +10272,7 @@ namespace VULKAN_HPP_NAMESPACE
       PipelineCache::merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ),
                                                 static_cast<VkPipelineCache>( m_pipelineCache ),
                                                 srcCaches.size(),
                                                 reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
@@ -10708,7 +10352,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_INLINE void
       DescriptorPool::reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
     {
-      getDispatcher()->vkResetDescriptorPool( static_cast<VkDevice>( **m_device ),
+      getDispatcher()->vkResetDescriptorPool( static_cast<VkDevice>( m_device ),
                                               static_cast<VkDescriptorPool>( m_descriptorPool ),
                                               static_cast<VkDescriptorPoolResetFlags>( flags ) );
     }
@@ -10749,7 +10393,7 @@ namespace VULKAN_HPP_NAMESPACE
                                            RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_NAMESPACE::Extent2D granularity;
-      getDispatcher()->vkGetRenderAreaGranularity( static_cast<VkDevice>( **m_device ),
+      getDispatcher()->vkGetRenderAreaGranularity( static_cast<VkDevice>( m_device ),
                                                    static_cast<VkRenderPass>( m_renderPass ),
                                                    reinterpret_cast<VkExtent2D *>( &granularity ) );
       return granularity;
@@ -10765,7 +10409,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_INLINE void CommandPool::reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags ) const
     {
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkResetCommandPool( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkResetCommandPool( static_cast<VkDevice>( m_device ),
                                              static_cast<VkCommandPool>( m_commandPool ),
                                              static_cast<VkCommandPoolResetFlags>( flags ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -11685,7 +11329,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_INLINE void
       CommandPool::trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
     {
-      getDispatcher()->vkTrimCommandPool( static_cast<VkDevice>( **m_device ),
+      getDispatcher()->vkTrimCommandPool( static_cast<VkDevice>( m_device ),
                                           static_cast<VkCommandPool>( m_commandPool ),
                                           static_cast<VkCommandPoolTrimFlags>( flags ) );
     }
@@ -11717,7 +11361,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          const void * pData ) const VULKAN_HPP_NOEXCEPT
     {
       getDispatcher()->vkUpdateDescriptorSetWithTemplate(
-        static_cast<VkDevice>( **m_device ),
+        static_cast<VkDevice>( m_device ),
         static_cast<VkDescriptorSet>( m_descriptorSet ),
         static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
         pData );
@@ -11854,7 +11498,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
     {
       getDispatcher()->vkResetQueryPool(
-        static_cast<VkDevice>( **m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
+        static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const
@@ -11862,7 +11506,7 @@ namespace VULKAN_HPP_NAMESPACE
       uint64_t                     value;
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValue(
-          static_cast<VkDevice>( **m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" );
@@ -12055,16 +11699,16 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( **m_device ),
-                                                    static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+          getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
+                                                    static_cast<VkSwapchainKHR>( m_swapchain ),
                                                     &swapchainImageCount,
                                                     nullptr ) );
         if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount )
         {
           swapchainImages.resize( swapchainImageCount );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( **m_device ),
-                                                      static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+            getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
+                                                      static_cast<VkSwapchainKHR>( m_swapchain ),
                                                       &swapchainImageCount,
                                                       swapchainImages.data() ) );
           VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
@@ -12091,8 +11735,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       uint32_t                     imageIndex;
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( **m_device ),
-                                                static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+        getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ),
+                                                static_cast<VkSwapchainKHR>( m_swapchain ),
                                                 timeout,
                                                 static_cast<VkSemaphore>( semaphore ),
                                                 static_cast<VkFence>( fence ),
@@ -12315,16 +11959,16 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( **m_physicalDevice ),
-                                                          static_cast<VkDisplayKHR>( m_displayKHR ),
+          getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                          static_cast<VkDisplayKHR>( m_display ),
                                                           &propertyCount,
                                                           nullptr ) );
         if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
         {
           properties.resize( propertyCount );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModePropertiesKHR(
-            static_cast<VkPhysicalDevice>( **m_physicalDevice ),
-            static_cast<VkDisplayKHR>( m_displayKHR ),
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            static_cast<VkDisplayKHR>( m_display ),
             &propertyCount,
             reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
           VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
@@ -12357,7 +12001,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities;
       VULKAN_HPP_NAMESPACE::Result                      result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR(
-          static_cast<VkPhysicalDevice>( **m_display->getPhysicalDevice() ),
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
           static_cast<VkDisplayModeKHR>( m_displayModeKHR ),
           planeIndex,
           reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) );
@@ -12689,16 +12333,16 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( **m_device ),
-                                                                   static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
+          getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
+                                                                   static_cast<VkVideoSessionKHR>( m_videoSession ),
                                                                    &videoSessionMemoryRequirementsCount,
                                                                    nullptr ) );
         if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoSessionMemoryRequirementsCount )
         {
           videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkVideoSessionKHR>( m_videoSession ),
             &videoSessionMemoryRequirementsCount,
             reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) );
           VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() );
@@ -12724,8 +12368,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindVideoSessionMemoryKHR(
-          static_cast<VkDevice>( **m_device ),
-          static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkVideoSessionKHR>( m_videoSession ),
           videoSessionBindMemories.size(),
           reinterpret_cast<const VkVideoBindMemoryKHR *>( videoSessionBindMemories.data() ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -12750,8 +12394,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkUpdateVideoSessionParametersKHR(
-          static_cast<VkDevice>( **m_device ),
-          static_cast<VkVideoSessionParametersKHR>( m_videoSessionParametersKHR ),
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
           reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
@@ -12993,7 +12637,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
       VULKAN_HPP_NAMESPACE::Result                        result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewAddressNVX(
-          static_cast<VkDevice>( **m_device ),
+          static_cast<VkDevice>( m_device ),
           static_cast<VkImageView>( m_imageView ),
           reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -13060,7 +12704,7 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( **m_device ),
+          getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
                                                static_cast<VkPipeline>( m_pipeline ),
                                                static_cast<VkShaderStageFlagBits>( shaderStage ),
                                                static_cast<VkShaderInfoTypeAMD>( infoType ),
@@ -13070,7 +12714,7 @@ namespace VULKAN_HPP_NAMESPACE
         {
           info.resize( infoSize );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( **m_device ),
+            getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
                                                  static_cast<VkPipeline>( m_pipeline ),
                                                  static_cast<VkShaderStageFlagBits>( shaderStage ),
                                                  static_cast<VkShaderInfoTypeAMD>( infoType ),
@@ -13167,8 +12811,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       HANDLE                       handle;
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetMemoryWin32HandleNV( static_cast<VkDevice>( **m_device ),
-                                                   static_cast<VkDeviceMemory>( m_deviceMemory ),
+        getDispatcher()->vkGetMemoryWin32HandleNV( static_cast<VkDevice>( m_device ),
+                                                   static_cast<VkDeviceMemory>( m_memory ),
                                                    static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ),
                                                    &handle ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -13485,7 +13129,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR &&
                          "Function <vkTrimCommandPoolKHR> needs extension <VK_KHR_maintenance1> enabled!" );
 
-      getDispatcher()->vkTrimCommandPoolKHR( static_cast<VkDevice>( **m_device ),
+      getDispatcher()->vkTrimCommandPoolKHR( static_cast<VkDevice>( m_device ),
                                              static_cast<VkCommandPool>( m_commandPool ),
                                              static_cast<VkCommandPoolTrimFlags>( flags ) );
     }
@@ -13823,7 +13467,7 @@ namespace VULKAN_HPP_NAMESPACE
         "Function <vkUpdateDescriptorSetWithTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
 
       getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR(
-        static_cast<VkDevice>( **m_device ),
+        static_cast<VkDevice>( m_device ),
         static_cast<VkDescriptorSet>( m_descriptorSet ),
         static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
         pData );
@@ -13936,8 +13580,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       uint64_t                     counterValue;
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetSwapchainCounterEXT( static_cast<VkDevice>( **m_device ),
-                                                   static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+        getDispatcher()->vkGetSwapchainCounterEXT( static_cast<VkDevice>( m_device ),
+                                                   static_cast<VkSwapchainKHR>( m_swapchain ),
                                                    static_cast<VkSurfaceCounterFlagBitsEXT>( counter ),
                                                    &counterValue ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -13959,8 +13603,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
       VULKAN_HPP_NAMESPACE::Result                     result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRefreshCycleDurationGOOGLE(
-          static_cast<VkDevice>( **m_device ),
-          static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkSwapchainKHR>( m_swapchain ),
           reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
@@ -13982,16 +13626,16 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( **m_device ),
-                                                              static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+          getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ),
+                                                              static_cast<VkSwapchainKHR>( m_swapchain ),
                                                               &presentationTimingCount,
                                                               nullptr ) );
         if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount )
         {
           presentationTimings.resize( presentationTimingCount );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPastPresentationTimingGOOGLE(
-            static_cast<VkDevice>( **m_device ),
-            static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkSwapchainKHR>( m_swapchain ),
             &presentationTimingCount,
             reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
           VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
@@ -14104,7 +13748,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainStatusKHR(
-          static_cast<VkDevice>( **m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) );
       if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
            ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
       {
@@ -14459,16 +14103,16 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( **m_physicalDevice ),
-                                                           static_cast<VkDisplayKHR>( m_displayKHR ),
+          getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                           static_cast<VkDisplayKHR>( m_display ),
                                                            &propertyCount,
                                                            nullptr ) );
         if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
         {
           properties.resize( propertyCount );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModeProperties2KHR(
-            static_cast<VkPhysicalDevice>( **m_physicalDevice ),
-            static_cast<VkDisplayKHR>( m_displayKHR ),
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            static_cast<VkDisplayKHR>( m_display ),
             &propertyCount,
             reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
           VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
@@ -15233,7 +14877,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties;
       VULKAN_HPP_NAMESPACE::Result                              result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT(
-          static_cast<VkDevice>( **m_device ),
+          static_cast<VkDevice>( m_device ),
           static_cast<VkImage>( m_image ),
           reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -15261,8 +14905,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMergeValidationCachesEXT(
-          static_cast<VkDevice>( **m_device ),
-          static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkValidationCacheEXT>( m_validationCache ),
           srcCaches.size(),
           reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -15282,16 +14926,16 @@ namespace VULKAN_HPP_NAMESPACE
       do
       {
         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( **m_device ),
-                                                        static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
+          getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ),
+                                                        static_cast<VkValidationCacheEXT>( m_validationCache ),
                                                         &dataSize,
                                                         nullptr ) );
         if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
         {
           data.resize( dataSize );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( **m_device ),
-                                                          static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
+            getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ),
+                                                          static_cast<VkValidationCacheEXT>( m_validationCache ),
                                                           &dataSize,
                                                           reinterpret_cast<void *>( data.data() ) ) );
           VULKAN_HPP_ASSERT( dataSize <= data.size() );
@@ -15519,7 +15163,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
       std::vector<T> data( dataSize / sizeof( T ) );
       Result         result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
                                                               static_cast<VkPipeline>( m_pipeline ),
                                                               firstGroup,
                                                               groupCount,
@@ -15537,7 +15181,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       T      data;
       Result result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
                                                               static_cast<VkPipeline>( m_pipeline ),
                                                               firstGroup,
                                                               groupCount,
@@ -15559,8 +15203,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
       std::vector<T> data( dataSize / sizeof( T ) );
       Result         result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
-        static_cast<VkDevice>( **m_device ),
-        static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
         data.size() * sizeof( T ),
         reinterpret_cast<void *>( data.data() ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -15575,8 +15219,8 @@ namespace VULKAN_HPP_NAMESPACE
     {
       T      data;
       Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
-        static_cast<VkDevice>( **m_device ),
-        static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
         sizeof( T ),
         reinterpret_cast<void *>( &data ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@@ -15612,7 +15256,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCompileDeferredNV(
-          static_cast<VkDevice>( **m_device ), static_cast<VkPipeline>( m_pipeline ), shader ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" );
@@ -15928,7 +15572,7 @@ namespace VULKAN_HPP_NAMESPACE
       uint64_t                     value;
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValueKHR(
-          static_cast<VkDevice>( **m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" );
@@ -16097,8 +15741,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD &&
                          "Function <vkSetLocalDimmingAMD> needs extension <VK_AMD_display_native_hdr> enabled!" );
 
-      getDispatcher()->vkSetLocalDimmingAMD( static_cast<VkDevice>( **m_device ),
-                                             static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+      getDispatcher()->vkSetLocalDimmingAMD( static_cast<VkDevice>( m_device ),
+                                             static_cast<VkSwapchainKHR>( m_swapchain ),
                                              static_cast<VkBool32>( localDimmingEnable ) );
     }
 
@@ -16238,7 +15882,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitForPresentKHR(
-          static_cast<VkDevice>( **m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ), presentId, timeout ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), presentId, timeout ) );
       if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
            ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
       {
@@ -16379,7 +16023,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT(
-          static_cast<VkDevice>( **m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" );
@@ -16394,7 +16038,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT(
-          static_cast<VkDevice>( **m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" );
@@ -16487,7 +16131,7 @@ namespace VULKAN_HPP_NAMESPACE
                          "Function <vkResetQueryPoolEXT> needs extension <VK_EXT_host_query_reset> enabled!" );
 
       getDispatcher()->vkResetQueryPoolEXT(
-        static_cast<VkDevice>( **m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
+        static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
     }
 
     //=== VK_EXT_extended_dynamic_state ===
@@ -16678,7 +16322,7 @@ namespace VULKAN_HPP_NAMESPACE
         "Function <vkGetDeferredOperationMaxConcurrencyKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
 
       return getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR(
-        static_cast<VkDevice>( **m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) );
+        static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
@@ -16689,7 +16333,7 @@ namespace VULKAN_HPP_NAMESPACE
         "Function <vkGetDeferredOperationResultKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
 
       return static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeferredOperationResultKHR(
-        static_cast<VkDevice>( **m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) ) );
+        static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) );
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::join() const
@@ -16700,7 +16344,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDeferredOperationJoinKHR(
-          static_cast<VkDevice>( **m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) ) );
+          static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) );
       if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
            ( result != VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR ) &&
            ( result != VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR ) )
@@ -17216,7 +16860,7 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireWinrtDisplayNV(
-          static_cast<VkPhysicalDevice>( **m_physicalDevice ), static_cast<VkDisplayKHR>( m_displayKHR ) ) );
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" );
@@ -17313,7 +16957,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
       std::vector<T> data( dataSize / sizeof( T ) );
       Result         result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
                                                                static_cast<VkPipeline>( m_pipeline ),
                                                                firstGroup,
                                                                groupCount,
@@ -17331,7 +16975,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       T      data;
       Result result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
                                                                static_cast<VkPipeline>( m_pipeline ),
                                                                firstGroup,
                                                                groupCount,
@@ -17355,7 +16999,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
       std::vector<T> data( dataSize / sizeof( T ) );
       Result         result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
                                                                             static_cast<VkPipeline>( m_pipeline ),
                                                                             firstGroup,
                                                                             groupCount,
@@ -17375,7 +17019,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       T      data;
       Result result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
                                                                             static_cast<VkPipeline>( m_pipeline ),
                                                                             firstGroup,
                                                                             groupCount,
@@ -17418,7 +17062,7 @@ namespace VULKAN_HPP_NAMESPACE
         "Function <vkGetRayTracingShaderGroupStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
 
       return static_cast<VULKAN_HPP_NAMESPACE::DeviceSize>(
-        getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( static_cast<VkDevice>( **m_device ),
+        getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( static_cast<VkDevice>( m_device ),
                                                                  static_cast<VkPipeline>( m_pipeline ),
                                                                  group,
                                                                  static_cast<VkShaderGroupShaderKHR>( groupShader ) ) );
@@ -17561,8 +17205,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA(
-          static_cast<VkDevice>( **m_device ),
-          static_cast<VkBufferCollectionFUCHSIA>( m_bufferCollectionFUCHSIA ),
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
           reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
@@ -17579,8 +17223,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA(
-          static_cast<VkDevice>( **m_device ),
-          static_cast<VkBufferCollectionFUCHSIA>( m_bufferCollectionFUCHSIA ),
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
           reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
@@ -17598,8 +17242,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties;
       VULKAN_HPP_NAMESPACE::Result                            result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA(
-          static_cast<VkDevice>( **m_device ),
-          static_cast<VkBufferCollectionFUCHSIA>( m_bufferCollectionFUCHSIA ),
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
           reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
@@ -17621,7 +17265,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize;
       VULKAN_HPP_NAMESPACE::Result   result =
         static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
-          static_cast<VkDevice>( **m_device ),
+          static_cast<VkDevice>( m_device ),
           static_cast<VkRenderPass>( m_renderPass ),
           reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) ) );
       if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
@@ -17820,7 +17464,7 @@ namespace VULKAN_HPP_NAMESPACE
         "Function <vkSetDeviceMemoryPriorityEXT> needs extension <VK_EXT_pageable_device_local_memory> enabled!" );
 
       getDispatcher()->vkSetDeviceMemoryPriorityEXT(
-        static_cast<VkDevice>( **m_device ), static_cast<VkDeviceMemory>( m_deviceMemory ), priority );
+        static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), priority );
     }
 
     //=== VK_KHR_maintenance4 ===