diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 0a79880..0993c6e 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -3142,7 +3142,7 @@ std::string VulkanHppGenerator::generateCommandDefinitions( std::string const &
     {
       std::string toEncloseString = stripPrefix( handle, "Vk" ) + "::free";
       std::string enclosedString  = "( " + toEncloseString + " )";
-      pos             = destroyCommandString.find( toEncloseString );
+      pos                         = destroyCommandString.find( toEncloseString );
       while ( pos != std::string::npos )
       {
         destroyCommandString.replace( pos, toEncloseString.length(), enclosedString );
@@ -6878,8 +6878,11 @@ std::string VulkanHppGenerator::generateRAIIHandle( std::pair<std::string, Handl
         ? std::make_pair( "", "" )
         : generateRAIIHandleDestructor( handle.first, handle.second.destructorIt, enter );
 
-    auto [getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions] =
-      generateRAIIHandleDetails( handle, destructorCall );
+    auto [getConstructorSuccessCode,
+          memberVariables,
+          moveConstructorInitializerList,
+          moveAssignmentInstructions,
+          swapMembers] = generateRAIIHandleDetails( handle, destructorCall );
 
     std::string declarations = generateRAIIHandleCommandDeclarations( handle, specialFunctions );
 
@@ -6963,6 +6966,12 @@ ${getParent}
       VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
       return ${getDispatcherReturn}m_dispatcher;
     }
+
+    void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::${handleType} & rhs )
+    {
+${swapMembers}
+    }
+
 ${memberFunctionsDeclarations}
 
   private:
@@ -6987,7 +6996,8 @@ ${leave})";
         { "moveAssignmentInstructions", moveAssignmentInstructions },
         { "moveConstructorInitializerList", moveConstructorInitializerList },
         { "objTypeEnum", objTypeEnum },
-        { "singularConstructors", singularConstructors } } );
+        { "singularConstructors", singularConstructors },
+        { "swapMembers", swapMembers } } );
 
     if ( !arrayConstructors.empty() )
     {
@@ -10521,14 +10531,22 @@ std::string VulkanHppGenerator::generateRAIIHandleContext( std::pair<std::string
         return *this;
       }
 
-${memberFunctionDeclarations}
-
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
       {
         VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
         return &*m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context & rhs )
+      {
+#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
+        std::swap( m_dynamicLoader, rhs.m_dynamicLoader );
+#endif
+        m_dispatcher.swap( rhs.m_dispatcher );
+      }
+
+${memberFunctionDeclarations}
+
     private:
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
       VULKAN_HPP_NAMESPACE::DynamicLoader                                                 m_dynamicLoader;
@@ -10641,7 +10659,7 @@ std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments(
   return arguments;
 }
 
-std::tuple<std::string, std::string, std::string, std::string>
+std::tuple<std::string, std::string, std::string, std::string, std::string>
   VulkanHppGenerator::generateRAIIHandleDetails( std::pair<std::string, HandleData> const & handle,
                                                  std::string const &                        destructorCall ) const
 {
@@ -10662,37 +10680,25 @@ std::tuple<std::string, std::string, std::string, std::string>
   std::string handleType = stripPrefix( handle.first, "Vk" );
   std::string handleName = generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt );
 
-  std::string moveConstructorInitializerList, moveAssignmentInstructions, memberVariables;
+  std::string moveConstructorInitializerList, moveAssignmentInstructions, memberVariables, swapMembers;
   if ( handle.second.destructorIt != m_commands.end() )
   {
-    moveAssignmentInstructions = "        if ( m_" + handleName +
-                                 " )\n"
-                                 "        {\n"
-                                 "          getDispatcher()->" +
-                                 destructorCall +
-                                 ";\n"
-                                 "        }";
+    moveAssignmentInstructions = "        if ( m_" + handleName + " )\n";
+    moveAssignmentInstructions += "        {\n";
+    moveAssignmentInstructions += "          getDispatcher()->" + destructorCall + ";\n";
+    moveAssignmentInstructions += "        }";
     for ( auto const & destructorParam : handle.second.destructorIt->second.params )
     {
+      std::string memberName, memberType;
       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 + " = {};";
+        memberName = parentName;
+        memberType = "VULKAN_HPP_NAMESPACE::" + parentType;
       }
       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 + " = {};";
+        memberName = handleName;
+        memberType = "VULKAN_HPP_NAMESPACE::" + handleType;
       }
       else if ( std::find_if( handle.second.destructorIt->second.params.begin(),
                               handle.second.destructorIt->second.params.end(),
@@ -10704,13 +10710,19 @@ std::tuple<std::string, std::string, std::string, std::string>
         {
           name = startLowerCase( stripPrefix( name, "p" ) );
         }
-        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 +
-                                      ", {} );";
+        memberName = name;
+        memberType = destructorParam.type.compose( "VULKAN_HPP_NAMESPACE" );
+      }
+      if ( !memberName.empty() )
+      {
+        moveConstructorInitializerList += "m_" + memberName +
+                                          "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                          memberName + ", {} ) ), ";
+        moveAssignmentInstructions += "\n          m_" + memberName +
+                                      " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
+                                      memberName + ", {} );";
+        memberVariables += "\n    " + memberType + " m_" + memberName + " = {};";
+        swapMembers += "\n      std::swap( m_" + memberName + ", rhs.m_" + memberName + " );";
       }
     }
   }
@@ -10734,6 +10746,7 @@ std::tuple<std::string, std::string, std::string, std::string>
                                    " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + frontName +
                                    ", {} );";
       memberVariables = "\n    VULKAN_HPP_NAMESPACE::" + stripPrefix( frontType, "Vk" ) + " m_" + frontName + " = {};";
+      swapMembers     = "\n      std::swap( m_" + frontName + ", rhs.m_" + frontName + " );";
     }
     moveConstructorInitializerList += "m_" + handleName +
                                       "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
@@ -10742,11 +10755,13 @@ std::tuple<std::string, std::string, std::string, std::string>
                                   " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName +
                                   ", {} );";
     memberVariables += "\n    VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + " = {};";
+    swapMembers += "\n      std::swap( m_" + handleName + ", rhs.m_" + handleName + " );";
   }
 
   if ( multiSuccessCodeContructor )
   {
     memberVariables += "\n    VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode;";
+    swapMembers += "\n      std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );";
   }
 
   if ( handle.first == "VkInstance" )
@@ -10769,6 +10784,7 @@ std::tuple<std::string, std::string, std::string, std::string>
     memberVariables +=
       "\n      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;";
   }
+  swapMembers += "\n      std::swap( m_dispatcher, rhs.m_dispatcher );";
 
   if ( ( handle.first == "VkInstance" ) || ( handle.first == "VkDevice" ) )
   {
@@ -10783,8 +10799,11 @@ std::tuple<std::string, std::string, std::string, std::string>
       "\n        m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );";
   }
 
-  return std::make_tuple(
-    getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions );
+  return std::make_tuple( getConstructorSuccessCode,
+                          memberVariables,
+                          moveConstructorInitializerList,
+                          moveAssignmentInstructions,
+                          swapMembers );
 }
 
 std::string VulkanHppGenerator::generateRAIIHandleForwardDeclarations( std::vector<RequireData> const & requireData,
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 50a829d..2c9108e 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -1123,7 +1123,7 @@ private:
   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>
+  std::tuple<std::string, std::string, std::string, std::string, std::string>
               generateRAIIHandleDetails( std::pair<std::string, HandleData> const & handle,
                                          std::string const &                        destructorCall ) const;
   std::string generateRAIIHandleForwardDeclarations( std::vector<RequireData> const & requireData,
diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp
index a530430..326d5f2 100644
--- a/vulkan/vulkan_raii.hpp
+++ b/vulkan/vulkan_raii.hpp
@@ -2517,6 +2517,20 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
+      {
+        VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
+        return &*m_dispatcher;
+      }
+
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context & rhs )
+      {
+#  if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
+        std::swap( m_dynamicLoader, rhs.m_dynamicLoader );
+#  endif
+        m_dispatcher.swap( rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Instance createInstance(
@@ -2532,12 +2546,6 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NODISCARD uint32_t enumerateInstanceVersion() const;
 
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
-      {
-        VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
-        return &*m_dispatcher;
-      }
-
     private:
 #  if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
       VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader;
@@ -2629,6 +2637,13 @@ namespace VULKAN_HPP_NAMESPACE
         return &*m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance & rhs )
+      {
+        std::swap( m_instance, rhs.m_instance );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> enumeratePhysicalDevices() const;
@@ -2788,7 +2803,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     private:
       VULKAN_HPP_NAMESPACE::Instance                                                       m_instance  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                                    m_allocator = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                                    m_allocator = {};
       std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher;
     };
 
@@ -2838,6 +2853,12 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice & rhs )
+      {
+        std::swap( m_physicalDevice, rhs.m_physicalDevice );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT;
@@ -3315,6 +3336,13 @@ namespace VULKAN_HPP_NAMESPACE
         return &*m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
@@ -4033,7 +4061,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     private:
       VULKAN_HPP_NAMESPACE::Device                                                       m_device    = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                                  m_allocator = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                                  m_allocator = {};
       std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher;
     };
 
@@ -4137,10 +4165,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device                = {};
       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                            m_accelerationStructure = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator             = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator             = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher            = nullptr;
     };
 
@@ -4244,6 +4280,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_NV_ray_tracing ===
 
       template <typename DataType>
@@ -4255,7 +4299,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device                = {};
       VULKAN_HPP_NAMESPACE::AccelerationStructureNV                             m_accelerationStructure = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator             = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator             = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher            = nullptr;
     };
 
@@ -4352,6 +4396,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_buffer, rhs.m_buffer );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
@@ -4361,7 +4413,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::Buffer                                              m_buffer     = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -4464,6 +4516,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_collection, rhs.m_collection );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_FUCHSIA_buffer_collection ===
 
       void setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const;
@@ -4476,7 +4536,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                             m_collection = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
@@ -4574,10 +4634,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_bufferView, rhs.m_bufferView );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::BufferView                                          m_bufferView = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -4674,6 +4742,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_commandPool, rhs.m_commandPool );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       void reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
@@ -4691,7 +4767,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device      = {};
       VULKAN_HPP_NAMESPACE::CommandPool                                         m_commandPool = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator   = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator   = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher  = nullptr;
     };
 
@@ -4772,6 +4848,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_commandPool, rhs.m_commandPool );
+        std::swap( m_commandBuffer, rhs.m_commandBuffer );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       void begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const;
@@ -5709,10 +5793,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_function, rhs.m_function );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::CuFunctionNVX                                       m_function   = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -5809,10 +5901,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_module, rhs.m_module );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::CuModuleNVX                                         m_module     = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -5914,10 +6014,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT & rhs )
+      {
+        std::swap( m_instance, rhs.m_instance );
+        std::swap( m_callback, rhs.m_callback );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Instance                                              m_instance   = {};
       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                                m_callback   = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -6019,10 +6127,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT & rhs )
+      {
+        std::swap( m_instance, rhs.m_instance );
+        std::swap( m_messenger, rhs.m_messenger );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Instance                                              m_instance   = {};
       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT                                m_messenger  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -6122,6 +6238,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_operation, rhs.m_operation );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_KHR_deferred_host_operations ===
 
       VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT;
@@ -6133,7 +6257,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                m_operation  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -6233,6 +6357,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_descriptorPool, rhs.m_descriptorPool );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       void reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
@@ -6241,7 +6373,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device         = {};
       VULKAN_HPP_NAMESPACE::DescriptorPool                                      m_descriptorPool = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator      = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator      = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher     = nullptr;
     };
 
@@ -6322,6 +6454,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_descriptorPool, rhs.m_descriptorPool );
+        std::swap( m_descriptorSet, rhs.m_descriptorSet );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_1 ===
 
       template <typename DataType>
@@ -6474,10 +6614,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device              = {};
       VULKAN_HPP_NAMESPACE::DescriptorSetLayout                                 m_descriptorSetLayout = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator           = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator           = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher          = nullptr;
     };
 
@@ -6581,10 +6729,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device                   = {};
       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                            m_descriptorUpdateTemplate = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator                = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator                = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher               = nullptr;
     };
 
@@ -6683,6 +6839,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_memory, rhs.m_memory );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD void *
@@ -6708,7 +6872,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::DeviceMemory                                        m_memory     = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -6830,6 +6994,13 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR & rhs )
+      {
+        std::swap( m_physicalDevice, rhs.m_physicalDevice );
+        std::swap( m_display, rhs.m_display );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_KHR_display ===
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const;
@@ -6968,6 +7139,13 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR & rhs )
+      {
+        std::swap( m_physicalDevice, rhs.m_physicalDevice );
+        std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_KHR_display ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
@@ -7072,6 +7250,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_event, rhs.m_event );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
@@ -7083,7 +7269,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::Event                                               m_event      = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -7220,6 +7406,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_fence, rhs.m_fence );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
@@ -7227,7 +7421,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::Fence                                               m_fence      = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -7324,10 +7518,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_framebuffer, rhs.m_framebuffer );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device      = {};
       VULKAN_HPP_NAMESPACE::Framebuffer                                         m_framebuffer = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator   = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator   = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher  = nullptr;
     };
 
@@ -7424,6 +7626,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_image, rhs.m_image );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
@@ -7444,7 +7654,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::Image                                               m_image      = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -7541,6 +7751,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_imageView, rhs.m_imageView );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_NVX_image_view_handle ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const;
@@ -7548,7 +7766,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::ImageView                                           m_imageView  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -7652,10 +7870,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device                 = {};
       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                            m_indirectCommandsLayout = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator              = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator              = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher             = nullptr;
     };
 
@@ -7742,6 +7968,13 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_configuration, rhs.m_configuration );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device        = {};
       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL                       m_configuration = {};
@@ -7844,6 +8077,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_pipelineCache, rhs.m_pipelineCache );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
@@ -7853,7 +8094,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device        = {};
       VULKAN_HPP_NAMESPACE::PipelineCache                                       m_pipelineCache = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator     = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator     = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher    = nullptr;
     };
 
@@ -8043,6 +8284,15 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_pipeline, rhs.m_pipeline );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_AMD_shader_info ===
 
       VULKAN_HPP_NODISCARD std::vector<uint8_t>
@@ -8083,7 +8333,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device    = {};
       VULKAN_HPP_NAMESPACE::Pipeline                                            m_pipeline  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator = {};
       VULKAN_HPP_NAMESPACE::Result                                              m_constructorSuccessCode;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
@@ -8331,10 +8581,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device         = {};
       VULKAN_HPP_NAMESPACE::PipelineLayout                                      m_pipelineLayout = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator      = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator      = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher     = nullptr;
     };
 
@@ -8434,10 +8692,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device          = {};
       VULKAN_HPP_NAMESPACE::PrivateDataSlot                                     m_privateDataSlot = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher      = nullptr;
     };
 
@@ -8534,6 +8800,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_queryPool, rhs.m_queryPool );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       template <typename DataType>
@@ -8562,7 +8836,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::QueryPool                                           m_queryPool  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -8629,6 +8903,12 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue & rhs )
+      {
+        std::swap( m_queue, rhs.m_queue );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       void submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
@@ -8792,6 +9072,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_renderPass, rhs.m_renderPass );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT;
@@ -8804,7 +9092,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::RenderPass                                          m_renderPass = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -8901,10 +9189,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_sampler, rhs.m_sampler );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::Sampler                                             m_sampler    = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -9006,10 +9302,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device          = {};
       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion                              m_ycbcrConversion = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher      = nullptr;
     };
 
@@ -9106,6 +9410,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_semaphore, rhs.m_semaphore );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_VERSION_1_2 ===
 
       VULKAN_HPP_NODISCARD uint64_t getCounterValue() const;
@@ -9117,7 +9429,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::Semaphore                                           m_semaphore  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -9217,10 +9529,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_shaderModule, rhs.m_shaderModule );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device       = {};
       VULKAN_HPP_NAMESPACE::ShaderModule                                        m_shaderModule = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator    = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator    = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher   = nullptr;
     };
 
@@ -9610,10 +9930,18 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR & rhs )
+      {
+        std::swap( m_instance, rhs.m_instance );
+        std::swap( m_surface, rhs.m_surface );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
     private:
       VULKAN_HPP_NAMESPACE::Instance                                              m_instance   = {};
       VULKAN_HPP_NAMESPACE::SurfaceKHR                                            m_surface    = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                           m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -9713,6 +10041,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_swapchain, rhs.m_swapchain );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_KHR_swapchain ===
 
       VULKAN_HPP_NODISCARD std::vector<VkImage> getImages() const;
@@ -9756,7 +10092,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device     = {};
       VULKAN_HPP_NAMESPACE::SwapchainKHR                                        m_swapchain  = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator  = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
     };
 
@@ -9897,6 +10233,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_validationCache, rhs.m_validationCache );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_EXT_validation_cache ===
 
       void merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const;
@@ -9906,7 +10250,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device          = {};
       VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                  m_validationCache = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator       = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher      = nullptr;
     };
 
@@ -10007,6 +10351,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_videoSession, rhs.m_videoSession );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_KHR_video_queue ===
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> getMemoryRequirements() const;
@@ -10017,7 +10369,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device       = {};
       VULKAN_HPP_NAMESPACE::VideoSessionKHR                                     m_videoSession = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator    = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator    = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher   = nullptr;
     };
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -10123,6 +10475,14 @@ namespace VULKAN_HPP_NAMESPACE
         return m_dispatcher;
       }
 
+      void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs )
+      {
+        std::swap( m_device, rhs.m_device );
+        std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters );
+        std::swap( m_allocator, rhs.m_allocator );
+        std::swap( m_dispatcher, rhs.m_dispatcher );
+      }
+
       //=== VK_KHR_video_queue ===
 
       void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const;
@@ -10130,7 +10490,7 @@ namespace VULKAN_HPP_NAMESPACE
     private:
       VULKAN_HPP_NAMESPACE::Device                                              m_device                 = {};
       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                           m_videoSessionParameters = {};
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator              = nullptr;
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                         m_allocator              = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher             = nullptr;
     };
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/