diff --git a/include/vk_video/vulkan_video_codec_h264std_decode.h b/include/vk_video/vulkan_video_codec_h264std_decode.h
index 6f2d6d7..cb0d1df 100644
--- a/include/vk_video/vulkan_video_codec_h264std_decode.h
+++ b/include/vk_video/vulkan_video_codec_h264std_decode.h
@@ -29,6 +29,7 @@
 typedef struct StdVideoDecodeH264PictureInfoFlags {
     uint32_t field_pic_flag : 1;             // Is field picture
     uint32_t is_intra : 1;                   // Is intra picture
+    uint32_t IdrPicFlag : 1;                 // instantaneous decoding refresh (IDR) picture
     uint32_t bottom_field_flag : 1;          // bottom (true) or top (false) field if field_pic_flag is set.
     uint32_t is_reference : 1;               // This only applies to picture info, and not to the DPB lists.
     uint32_t complementary_field_pair : 1;   // complementary field pair, complementary non-reference field pair, complementary reference field pair
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 2688e79..406253a 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -119,7 +119,7 @@
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 197, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 198, "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index a2f4e77..2bd3f77 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -72,7 +72,7 @@
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 197
+#define VK_HEADER_VERSION 198
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp
index 3edea17..4c925f8 100644
--- a/include/vulkan/vulkan_raii.hpp
+++ b/include/vulkan/vulkan_raii.hpp
@@ -63,11 +63,8 @@
     class InstanceDispatcher : public DispatchLoaderBase
     {
     public:
-      InstanceDispatcher( PFN_vkGetInstanceProcAddr getProcAddr ) : vkGetInstanceProcAddr( getProcAddr ) {}
-
-      InstanceDispatcher( std::nullptr_t ) : DispatchLoaderBase( nullptr ) {}
-
-      void init( VkInstance instance )
+      InstanceDispatcher( PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance )
+        : vkGetInstanceProcAddr( getProcAddr )
       {
         //=== VK_VERSION_1_0 ===
         vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
@@ -680,11 +677,7 @@
     class DeviceDispatcher : public DispatchLoaderBase
     {
     public:
-      DeviceDispatcher( PFN_vkGetDeviceProcAddr getProcAddr ) : vkGetDeviceProcAddr( getProcAddr ) {}
-
-      DeviceDispatcher( std::nullptr_t ) : DispatchLoaderBase( nullptr ) {}
-
-      void init( VkDevice device )
+      DeviceDispatcher( PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device ) : vkGetDeviceProcAddr( getProcAddr )
       {
         //=== VK_VERSION_1_0 ===
         vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
@@ -2316,7 +2309,9 @@
     class Context
     {
     public:
-      Context() : m_dispatcher( m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) )
+      Context()
+        : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher(
+            m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) ) )
       {}
 
       ~Context() = default;
@@ -2324,7 +2319,7 @@
       Context( Context const & ) = delete;
       Context( Context && rhs ) VULKAN_HPP_NOEXCEPT
         : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) )
-        , m_dispatcher( std::move( rhs.m_dispatcher ) )
+        , m_dispatcher( rhs.m_dispatcher.release() )
       {}
       Context & operator=( Context const & ) = delete;
       Context & operator                     =( Context && rhs ) VULKAN_HPP_NOEXCEPT
@@ -2332,7 +2327,7 @@
         if ( this != &rhs )
         {
           m_dynamicLoader = std::move( rhs.m_dynamicLoader );
-          m_dispatcher    = std::move( rhs.m_dispatcher );
+          m_dispatcher.reset( rhs.m_dispatcher.release() );
         }
         return *this;
       }
@@ -2354,13 +2349,13 @@
 
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
       {
-        VULKAN_HPP_ASSERT( m_dispatcher.getVkHeaderVersion() == VK_HEADER_VERSION );
-        return &m_dispatcher;
+        VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
+        return &*m_dispatcher;
       }
 
     private:
-      VULKAN_HPP_NAMESPACE::DynamicLoader                                m_dynamicLoader;
-      VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher m_dispatcher;
+      VULKAN_HPP_NAMESPACE::DynamicLoader                                                 m_dynamicLoader;
+      std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher> m_dispatcher;
     };
 
     class Instance
@@ -2377,32 +2372,28 @@
       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_dispatcher( context.getDispatcher()->vkGetInstanceProcAddr )
+        : 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 )
         {
           throwResultException( result, "vkCreateInstance" );
         }
-        m_dispatcher.init( static_cast<VkInstance>( m_instance ) );
+        m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher(
+          context.getDispatcher()->vkGetInstanceProcAddr, static_cast<VkInstance>( m_instance ) ) );
       }
 
       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_dispatcher( context.getDispatcher()->vkGetInstanceProcAddr )
+        : m_instance( instance )
+        , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
       {
-        m_dispatcher.init( static_cast<VkInstance>( m_instance ) );
+        m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher(
+          context.getDispatcher()->vkGetInstanceProcAddr, static_cast<VkInstance>( m_instance ) ) );
       }
 
       Instance( std::nullptr_t ) {}
@@ -2411,17 +2402,17 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        : 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;
       Instance & operator                      =( Instance && rhs ) VULKAN_HPP_NOEXCEPT
@@ -2430,12 +2421,12 @@
         {
           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_dispatcher = rhs.m_dispatcher;
+          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.reset( rhs.m_dispatcher.release() );
         }
         return *this;
       }
@@ -2445,15 +2436,10 @@
         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 );
-        return &m_dispatcher;
+        VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
+        return &*m_dispatcher;
       }
 
       //=== VK_VERSION_1_0 ===
@@ -2614,10 +2600,9 @@
 #  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::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher m_dispatcher = 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;
     };
 
     class PhysicalDevice
@@ -2633,7 +2618,7 @@
     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 ) {}
@@ -2641,18 +2626,16 @@
       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_dispatcher( rhs.m_dispatcher )
+        : 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;
       PhysicalDevice & operator                            =( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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     = rhs.m_dispatcher;
+          m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
@@ -2662,11 +2645,6 @@
         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 );
@@ -3015,9 +2993,8 @@
 #  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>
@@ -3077,33 +3054,29 @@
       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_dispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr )
+        : 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" );
         }
-        m_dispatcher.init( static_cast<VkDevice>( m_device ) );
+        m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher(
+          physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast<VkDevice>( m_device ) ) );
       }
 
       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_dispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr )
+        : m_device( device ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
       {
-        m_dispatcher.init( static_cast<VkDevice>( m_device ) );
+        m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher(
+          physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast<VkDevice>( m_device ) ) );
       }
 
       Device( std::nullptr_t ) {}
@@ -3112,17 +3085,17 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        : 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;
       Device & operator                    =( Device && rhs ) VULKAN_HPP_NOEXCEPT
@@ -3131,12 +3104,12 @@
         {
           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_dispatcher     = rhs.m_dispatcher;
+          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;
       }
@@ -3146,16 +3119,10 @@
         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 );
-        return &m_dispatcher;
+        VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
+        return &*m_dispatcher;
       }
 
       //=== VK_VERSION_1_0 ===
@@ -3836,10 +3803,9 @@
         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::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher       m_dispatcher = 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;
     };
 
     class AccelerationStructureKHR
@@ -3857,17 +3823,16 @@
         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" );
@@ -3876,12 +3841,11 @@
 
       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() )
       {}
 
@@ -3889,51 +3853,44 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -3945,10 +3902,10 @@
       }
 
     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
@@ -3966,17 +3923,16 @@
         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" );
@@ -3985,12 +3941,11 @@
 
       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() )
       {}
 
@@ -3998,51 +3953,44 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -4062,10 +4010,10 @@
       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
@@ -4082,15 +4030,14 @@
       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 )
         {
@@ -4101,10 +4048,9 @@
       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() )
       {}
 
@@ -4114,33 +4060,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Buffer & operator                    =( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -4150,7 +4092,7 @@
         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;
       }
@@ -4168,9 +4110,9 @@
       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;
     };
 
@@ -4190,17 +4132,16 @@
         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" );
@@ -4209,12 +4150,11 @@
 
       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() )
       {}
 
@@ -4222,51 +4162,42 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -4287,9 +4218,9 @@
       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*/
@@ -4308,15 +4239,14 @@
       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 )
         {
@@ -4327,10 +4257,9 @@
       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() )
       {}
 
@@ -4340,33 +4269,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       BufferView & operator                        =( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -4376,7 +4301,7 @@
         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;
       }
@@ -4388,9 +4313,9 @@
       }
 
     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;
     };
 
@@ -4408,15 +4333,14 @@
       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 )
         {
@@ -4427,10 +4351,9 @@
       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() )
       {}
 
@@ -4440,33 +4363,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       CommandPool & operator                         =( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher  = rhs.m_dispatcher;
+          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;
       }
@@ -4476,7 +4395,7 @@
         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;
       }
@@ -4502,10 +4421,10 @@
         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
@@ -4522,9 +4441,9 @@
       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() )
       {}
 
@@ -4534,8 +4453,8 @@
       {
         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 ) );
         }
@@ -4544,27 +4463,20 @@
       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( rhs.m_dispatcher )
+        , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       CommandBuffer & operator=( CommandBuffer const & ) = delete;
       CommandBuffer & operator                           =( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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    = rhs.m_dispatcher;
+          m_dispatcher    = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
@@ -4574,7 +4486,7 @@
         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;
       }
@@ -5305,10 +5217,10 @@
                                   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>
@@ -5359,17 +5271,16 @@
         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" );
@@ -5378,12 +5289,11 @@
 
       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() )
       {}
 
@@ -5391,45 +5301,41 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       CuFunctionNVX & operator                           =( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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    = rhs.m_dispatcher;
+          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;
       }
@@ -5441,9 +5347,9 @@
       }
 
     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;
     };
 
@@ -5461,16 +5367,15 @@
       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" );
@@ -5478,12 +5383,11 @@
       }
 
       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() )
       {}
 
@@ -5491,45 +5395,41 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       CuModuleNVX & operator                         =( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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  = rhs.m_dispatcher;
+          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;
       }
@@ -5541,9 +5441,9 @@
       }
 
     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;
     };
 
@@ -5562,17 +5462,16 @@
         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" );
@@ -5581,12 +5480,11 @@
 
       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() )
       {}
 
@@ -5594,51 +5492,42 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -5650,9 +5539,9 @@
       }
 
     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;
     };
 
@@ -5671,17 +5560,16 @@
         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" );
@@ -5690,12 +5578,11 @@
 
       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() )
       {}
 
@@ -5703,51 +5590,42 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -5759,9 +5637,9 @@
       }
 
     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;
     };
 
@@ -5779,16 +5657,15 @@
       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" );
@@ -5797,12 +5674,11 @@
 
       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() )
       {}
 
@@ -5810,50 +5686,42 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -5873,9 +5741,9 @@
       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;
     };
 
@@ -5894,16 +5762,15 @@
         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 )
         {
@@ -5915,10 +5782,9 @@
         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() )
       {}
 
@@ -5928,33 +5794,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       DescriptorPool & operator                            =( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher     = rhs.m_dispatcher;
+          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;
       }
@@ -5964,7 +5826,7 @@
         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;
       }
@@ -5981,10 +5843,10 @@
         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
@@ -6001,9 +5863,9 @@
       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() )
       {}
 
@@ -6013,8 +5875,8 @@
       {
         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 ) );
         }
@@ -6023,27 +5885,20 @@
       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( rhs.m_dispatcher )
+        , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DescriptorSet & operator=( DescriptorSet const & ) = delete;
       DescriptorSet & operator                           =( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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     = rhs.m_dispatcher;
+          m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
@@ -6053,7 +5908,7 @@
         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;
       }
@@ -6075,10 +5930,10 @@
                                   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>
@@ -6129,16 +5984,15 @@
         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 )
         {
@@ -6150,10 +6004,9 @@
         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() )
       {}
 
@@ -6163,37 +6016,32 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       DescriptorSetLayout & operator                                 =( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -6203,7 +6051,7 @@
         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;
       }
@@ -6215,10 +6063,10 @@
       }
 
     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
@@ -6236,16 +6084,15 @@
         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 )
         {
@@ -6257,10 +6104,9 @@
         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() )
       {}
 
@@ -6271,38 +6117,31 @@
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -6312,7 +6151,7 @@
         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;
       }
@@ -6324,10 +6163,10 @@
       }
 
     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
@@ -6345,16 +6184,15 @@
         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" );
@@ -6363,12 +6201,11 @@
 
       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() )
       {}
 
@@ -6376,45 +6213,41 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       DeviceMemory & operator                          =( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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   = rhs.m_dispatcher;
+          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;
       }
@@ -6448,9 +6281,9 @@
       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;
     };
 
@@ -6468,13 +6301,13 @@
       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" );
@@ -6485,14 +6318,14 @@
       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" );
@@ -6503,12 +6336,12 @@
 #  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" );
@@ -6517,54 +6350,46 @@
 #  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_dispatcher( rhs.m_dispatcher )
+        : 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;
       DisplayKHR & operator                        =( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher     = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -6594,9 +6419,9 @@
 #  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>
@@ -6658,11 +6483,11 @@
         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 *>(
@@ -6676,7 +6501,9 @@
 
       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 ) {}
@@ -6684,18 +6511,18 @@
       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( rhs.m_dispatcher )
+        , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
       {}
       DisplayModeKHR & operator=( DisplayModeKHR const & ) = delete;
       DisplayModeKHR & operator                            =( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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     = rhs.m_dispatcher;
+          m_dispatcher     = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
@@ -6705,11 +6532,6 @@
         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 );
@@ -6722,9 +6544,9 @@
                            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
@@ -6741,15 +6563,14 @@
       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 )
         {
@@ -6760,10 +6581,9 @@
       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() )
       {}
 
@@ -6773,33 +6593,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Event & operator                   =( Event && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -6809,7 +6625,7 @@
         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;
       }
@@ -6829,9 +6645,9 @@
       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;
     };
 
@@ -6849,15 +6665,14 @@
       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 )
         {
@@ -6868,16 +6683,15 @@
       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 )
         {
@@ -6889,9 +6703,8 @@
              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 =
@@ -6899,7 +6712,7 @@
             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 )
         {
@@ -6910,10 +6723,9 @@
       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() )
       {}
 
@@ -6923,33 +6735,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Fence & operator                   =( Fence && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -6959,7 +6767,7 @@
         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;
       }
@@ -6975,9 +6783,9 @@
       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;
     };
 
@@ -6995,15 +6803,14 @@
       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 )
         {
@@ -7014,10 +6821,9 @@
       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() )
       {}
 
@@ -7027,33 +6833,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Framebuffer & operator                         =( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher  = rhs.m_dispatcher;
+          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;
       }
@@ -7063,7 +6865,7 @@
         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;
       }
@@ -7075,10 +6877,10 @@
       }
 
     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
@@ -7095,15 +6897,14 @@
       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 )
         {
@@ -7114,10 +6915,9 @@
       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() )
       {}
 
@@ -7127,33 +6927,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Image & operator                   =( Image && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -7163,7 +6959,7 @@
         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;
       }
@@ -7192,9 +6988,9 @@
                            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;
     };
 
@@ -7212,15 +7008,14 @@
       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 )
         {
@@ -7231,10 +7026,9 @@
       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() )
       {}
 
@@ -7244,33 +7038,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       ImageView & operator                       =( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -7280,7 +7070,7 @@
         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;
       }
@@ -7296,9 +7086,9 @@
       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;
     };
 
@@ -7317,17 +7107,16 @@
         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" );
@@ -7336,12 +7125,11 @@
 
       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() )
       {}
 
@@ -7349,51 +7137,44 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -7405,10 +7186,10 @@
       }
 
     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
@@ -7425,13 +7206,13 @@
       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" );
@@ -7439,57 +7220,46 @@
       }
 
       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_dispatcher( rhs.m_dispatcher )
+        : 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;
       PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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 = rhs.m_dispatcher;
+          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;
       }
@@ -7501,9 +7271,9 @@
       }
 
     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
@@ -7521,16 +7291,15 @@
         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 )
         {
@@ -7542,10 +7311,9 @@
         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() )
       {}
 
@@ -7555,33 +7323,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       PipelineCache & operator                           =( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher    = rhs.m_dispatcher;
+          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;
       }
@@ -7591,7 +7355,7 @@
         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;
       }
@@ -7609,10 +7373,10 @@
       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
@@ -7632,9 +7396,8 @@
                                                                                         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(
@@ -7642,7 +7405,7 @@
           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 ) )
@@ -7657,9 +7420,8 @@
                                                                                         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 =
@@ -7668,7 +7430,7 @@
             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 ) )
@@ -7685,9 +7447,8 @@
                                                                                         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 =
@@ -7697,7 +7458,7 @@
             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 ) &&
@@ -7714,9 +7475,8 @@
                                                                                         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 =
@@ -7725,7 +7485,7 @@
             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 ) )
@@ -7738,10 +7498,9 @@
                 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() )
       {}
@@ -7752,33 +7511,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Pipeline & operator                      =( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -7793,7 +7548,7 @@
         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;
       }
@@ -7843,9 +7598,9 @@
         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;
     };
@@ -8012,16 +7767,15 @@
         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 )
         {
@@ -8033,10 +7787,9 @@
         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() )
       {}
 
@@ -8046,33 +7799,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       PipelineLayout & operator                            =( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher     = rhs.m_dispatcher;
+          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;
       }
@@ -8082,7 +7831,7 @@
         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;
       }
@@ -8094,10 +7843,10 @@
       }
 
     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
@@ -8115,17 +7864,16 @@
         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" );
@@ -8134,12 +7882,11 @@
 
       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() )
       {}
 
@@ -8147,49 +7894,42 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       PrivateDataSlotEXT & operator                                =( PrivateDataSlotEXT && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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 = rhs.m_dispatcher;
+          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;
       }
@@ -8201,10 +7941,10 @@
       }
 
     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
@@ -8221,15 +7961,14 @@
       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 )
         {
@@ -8240,10 +7979,9 @@
       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() )
       {}
 
@@ -8253,33 +7991,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       QueryPool & operator                       =( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -8289,7 +8023,7 @@
         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;
       }
@@ -8326,9 +8060,9 @@
       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;
     };
 
@@ -8346,7 +8080,7 @@
       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 ) );
@@ -8354,7 +8088,7 @@
 
       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 ),
@@ -8362,7 +8096,7 @@
       }
 
       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 ) {}
@@ -8370,18 +8104,16 @@
       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_dispatcher( rhs.m_dispatcher )
+        : 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;
       Queue & operator                   =( Queue && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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 = rhs.m_dispatcher;
+          m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
         }
         return *this;
       }
@@ -8391,11 +8123,6 @@
         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 );
@@ -8445,8 +8172,7 @@
                            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;
     };
 
@@ -8464,15 +8190,14 @@
       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 )
         {
@@ -8483,15 +8208,14 @@
       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 )
         {
@@ -8502,10 +8226,9 @@
       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() )
       {}
 
@@ -8515,33 +8238,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       RenderPass & operator                        =( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -8551,7 +8270,7 @@
         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;
       }
@@ -8572,9 +8291,9 @@
                            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;
     };
 
@@ -8592,15 +8311,14 @@
       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 )
         {
@@ -8611,10 +8329,9 @@
       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() )
       {}
 
@@ -8624,33 +8341,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Sampler & operator                     =( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -8660,7 +8373,7 @@
         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;
       }
@@ -8672,9 +8385,9 @@
       }
 
     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;
     };
 
@@ -8693,17 +8406,16 @@
         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" );
@@ -8712,12 +8424,11 @@
 
       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() )
       {}
 
@@ -8725,51 +8436,42 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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 = rhs.m_dispatcher;
+          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;
       }
@@ -8781,10 +8483,10 @@
       }
 
     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
@@ -8801,15 +8503,14 @@
       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 )
         {
@@ -8820,10 +8521,9 @@
       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() )
       {}
 
@@ -8833,33 +8533,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       Semaphore & operator                       =( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
@@ -8869,7 +8565,7 @@
         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;
       }
@@ -8889,9 +8585,9 @@
       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;
     };
 
@@ -8910,16 +8606,15 @@
         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 )
         {
@@ -8931,10 +8626,9 @@
         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() )
       {}
 
@@ -8944,33 +8638,29 @@
       {
         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_dispatcher( rhs.m_dispatcher )
+        , 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;
       ShaderModule & operator                          =( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher   = rhs.m_dispatcher;
+          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;
       }
@@ -8980,7 +8670,7 @@
         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;
       }
@@ -8992,10 +8682,10 @@
       }
 
     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
@@ -9013,17 +8703,16 @@
       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" );
@@ -9035,17 +8724,16 @@
       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" );
@@ -9056,17 +8744,16 @@
       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" );
@@ -9076,17 +8763,16 @@
       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" );
@@ -9097,17 +8783,16 @@
       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" );
@@ -9119,17 +8804,16 @@
       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" );
@@ -9141,17 +8825,16 @@
       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" );
@@ -9163,17 +8846,16 @@
       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" );
@@ -9185,17 +8867,16 @@
       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" );
@@ -9207,17 +8888,16 @@
       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" );
@@ -9229,17 +8909,16 @@
       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" );
@@ -9251,17 +8930,16 @@
       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" );
@@ -9273,17 +8951,16 @@
       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" );
@@ -9295,17 +8972,16 @@
       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" );
@@ -9317,17 +8993,16 @@
       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" );
@@ -9336,12 +9011,11 @@
 #  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() )
       {}
 
@@ -9349,45 +9023,41 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       SurfaceKHR & operator                        =( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -9399,9 +9069,9 @@
       }
 
     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;
     };
 
@@ -9420,17 +9090,16 @@
         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" );
@@ -9439,12 +9108,11 @@
 
       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() )
       {}
 
@@ -9452,45 +9120,41 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       SwapchainKHR & operator                          =( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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   = rhs.m_dispatcher;
+          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;
       }
@@ -9542,9 +9206,9 @@
 #  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;
     };
 
@@ -9602,17 +9266,16 @@
         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" );
@@ -9621,12 +9284,11 @@
 
       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() )
       {}
 
@@ -9634,49 +9296,42 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       ValidationCacheEXT & operator                                =( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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 = rhs.m_dispatcher;
+          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;
       }
@@ -9694,10 +9349,10 @@
       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 )
@@ -9716,17 +9371,16 @@
         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" );
@@ -9735,12 +9389,11 @@
 
       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() )
       {}
 
@@ -9748,45 +9401,41 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       VideoSessionKHR & operator                             =( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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      = rhs.m_dispatcher;
+          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;
       }
@@ -9805,10 +9454,10 @@
         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*/
 
@@ -9828,17 +9477,16 @@
         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" );
@@ -9847,12 +9495,11 @@
 
       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() )
       {}
 
@@ -9860,51 +9507,44 @@
 
       ~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_dispatcher( rhs.m_dispatcher )
+        : 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;
       VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
       {
         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_dispatcher = rhs.m_dispatcher;
+          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;
       }
 
       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;
       }
@@ -9920,10 +9560,10 @@
       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*/
 
@@ -10224,8 +9864,8 @@
     {
       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 ),
@@ -10239,8 +9879,7 @@
 
     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(
@@ -10275,8 +9914,8 @@
                                            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;
     }
@@ -10285,7 +9924,7 @@
                                                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 ) ) );
@@ -10299,7 +9938,7 @@
                                               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 ) ) );
@@ -10313,7 +9952,7 @@
                                            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;
@@ -10323,7 +9962,7 @@
                                            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;
@@ -10334,11 +9973,11 @@
     {
       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() ) );
@@ -10412,7 +10051,7 @@
     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 ) )
       {
@@ -10457,7 +10096,7 @@
     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 ) )
       {
@@ -10469,7 +10108,7 @@
     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" );
@@ -10479,7 +10118,7 @@
     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" );
@@ -10504,7 +10143,7 @@
       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,
@@ -10529,7 +10168,7 @@
     {
       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,
@@ -10570,7 +10209,7 @@
       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 ) );
@@ -10606,12 +10245,12 @@
       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() ) ) );
@@ -10633,7 +10272,7 @@
       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() ) ) );
@@ -10713,7 +10352,7 @@
     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 ) );
     }
@@ -10754,7 +10393,7 @@
                                            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;
@@ -10770,7 +10409,7 @@
     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 )
@@ -11690,7 +11329,7 @@
     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 ) );
     }
@@ -11722,7 +11361,7 @@
                                          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 );
@@ -11859,7 +11498,7 @@
     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
@@ -11867,7 +11506,7 @@
       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" );
@@ -12060,16 +11699,16 @@
       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() );
@@ -12096,8 +11735,8 @@
 
       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 ),
@@ -12320,16 +11959,16 @@
       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() );
@@ -12362,7 +12001,7 @@
       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 ) ) );
@@ -12694,16 +12333,16 @@
       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() );
@@ -12729,8 +12368,8 @@
 
       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 )
@@ -12755,8 +12394,8 @@
 
       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 )
       {
@@ -12998,7 +12637,7 @@
       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 )
@@ -13065,7 +12704,7 @@
       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 ),
@@ -13075,7 +12714,7 @@
         {
           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 ),
@@ -13172,8 +12811,8 @@
 
       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 )
@@ -13490,7 +13129,7 @@
       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 ) );
     }
@@ -13828,7 +13467,7 @@
         "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 );
@@ -13941,8 +13580,8 @@
 
       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 )
@@ -13964,8 +13603,8 @@
       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 )
       {
@@ -13987,16 +13626,16 @@
       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() );
@@ -14109,7 +13748,7 @@
 
       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 ) )
       {
@@ -14464,16 +14103,16 @@
       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() );
@@ -15238,7 +14877,7 @@
       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 )
@@ -15266,8 +14905,8 @@
 
       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 )
@@ -15287,16 +14926,16 @@
       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() );
@@ -15524,7 +15163,7 @@
       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,
@@ -15542,7 +15181,7 @@
     {
       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,
@@ -15564,8 +15203,8 @@
       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 )
@@ -15580,8 +15219,8 @@
     {
       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 )
@@ -15617,7 +15256,7 @@
 
       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" );
@@ -15933,7 +15572,7 @@
       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" );
@@ -16102,8 +15741,8 @@
       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 ) );
     }
 
@@ -16243,7 +15882,7 @@
 
       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 ) )
       {
@@ -16384,7 +16023,7 @@
 
       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" );
@@ -16399,7 +16038,7 @@
 
       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" );
@@ -16492,7 +16131,7 @@
                          "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 ===
@@ -16683,7 +16322,7 @@
         "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
@@ -16694,7 +16333,7 @@
         "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
@@ -16705,7 +16344,7 @@
 
       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 ) )
@@ -17221,7 +16860,7 @@
 
       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" );
@@ -17318,7 +16957,7 @@
       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,
@@ -17336,7 +16975,7 @@
     {
       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,
@@ -17360,7 +16999,7 @@
       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,
@@ -17380,7 +17019,7 @@
     {
       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,
@@ -17423,7 +17062,7 @@
         "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 ) ) );
@@ -17566,8 +17205,8 @@
 
       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 )
       {
@@ -17584,8 +17223,8 @@
 
       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 )
       {
@@ -17603,8 +17242,8 @@
       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 )
       {
@@ -17626,7 +17265,7 @@
       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 ) &&
@@ -17825,7 +17464,7 @@
         "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 ===
diff --git a/registry/validusage.json b/registry/validusage.json
index 5353094..4aaf037 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.197",
-    "comment": "from git branch: github-main commit: 2a43f68f2841054d7f2fb6a44c637c533a549dbb",
-    "date": "2021-11-02 08:48:49Z"
+    "api version": "1.2.198",
+    "comment": "from git branch: github-main commit: 3a4dc41cc86b4215e9995f20f2be744a106887d5",
+    "date": "2021-11-09 07:58:02Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -62,13 +62,13 @@
       "(VK_EXT_debug_report,VK_EXT_debug_utils)+(VK_EXT_debug_report)": [
         {
           "vuid": "VUID-VkInstanceCreateInfo-pNext-04925",
-          "text": " If the <code>pNext</code> chain of <code>VkInstanceCreateInfo</code> includes a <code>VkDebugReportCallbackCreateInfoEXT</code> structure, the list of enabled extensions in <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> contain VK_EXT_debug_report"
+          "text": " If the <code>pNext</code> chain of <code>VkInstanceCreateInfo</code> includes a <code>VkDebugReportCallbackCreateInfoEXT</code> structure, the list of enabled extensions in <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> contain <a href=\"#VK_EXT_debug_report\">VK_EXT_debug_report</a>"
         }
       ],
       "(VK_EXT_debug_report,VK_EXT_debug_utils)+(VK_EXT_debug_utils)": [
         {
           "vuid": "VUID-VkInstanceCreateInfo-pNext-04926",
-          "text": " If the <code>pNext</code> chain of <code>VkInstanceCreateInfo</code> includes a <code>VkDebugUtilsMessengerCreateInfoEXT</code> structure, the list of enabled extensions in <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> contain VK_EXT_debug_utils"
+          "text": " If the <code>pNext</code> chain of <code>VkInstanceCreateInfo</code> includes a <code>VkDebugUtilsMessengerCreateInfoEXT</code> structure, the list of enabled extensions in <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> contain <a href=\"#VK_EXT_debug_utils\">VK_EXT_debug_utils</a>"
         }
       ],
       "core": [
@@ -514,7 +514,7 @@
       "(VK_VERSION_1_2)+(VK_EXT_buffer_device_address)": [
         {
           "vuid": "VUID-VkDeviceCreateInfo-pNext-04748",
-          "text": " if the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure and <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>::<code>bufferDeviceAddress</code> is VK_TRUE, <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> not contain <code><a href=\"#VK_EXT_buffer_device_address\">VK_EXT_buffer_device_address</a></code>"
+          "text": " if the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure and <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>::<code>bufferDeviceAddress</code> is <code>VK_TRUE</code>, <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> not contain <code><a href=\"#VK_EXT_buffer_device_address\">VK_EXT_buffer_device_address</a></code>"
         }
       ],
       "(VK_VERSION_1_2)": [
@@ -813,6 +813,10 @@
         {
           "vuid": "VUID-VkDeviceQueueCreateInfo-flags-02861",
           "text": " If the <a href=\"#features-protectedMemory\">protected memory</a> feature is not enabled, the <code>VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT</code> bit of <code>flags</code> <strong class=\"purple\">must</strong> not be set"
+        },
+        {
+          "vuid": "VUID-VkDeviceQueueCreateInfo-flags-06449",
+          "text": " If <code>flags</code> includes <code>VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT</code>, <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be the index of a queue family that includes the <code>VK_QUEUE_PROTECTED_BIT</code> capability"
         }
       ]
     },
@@ -1502,6 +1506,12 @@
           "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03880",
           "text": " If a command recorded into the <code>commandBuffer</code> member of any element of the <code>pCommandBufferInfos</code> member of any element of <code>pSubmits</code> was a <a href=\"#vkCmdBeginQuery\">vkCmdBeginQuery</a> whose <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <a href=\"#profiling-lock\">profiling lock</a> <strong class=\"purple\">must</strong> have been held continuously on the <code>VkDevice</code> that <code>queue</code> was retrieved from, throughout recording of those command buffers"
         }
+      ],
+      "(VK_KHR_synchronization2)+(VK_VERSION_1_1)": [
+        {
+          "vuid": "VUID-vkQueueSubmit2KHR-queue-06447",
+          "text": " If <code>queue</code> was not created with <code>VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT</code>, the <code>flags</code> member of any element of <code>pSubmits</code> <strong class=\"purple\">must</strong> not include <code>VK_SUBMIT_PROTECTED_BIT_KHR</code>"
+        }
       ]
     },
     "VkSubmitInfo2KHR": {
@@ -1525,10 +1535,6 @@
       ],
       "(VK_KHR_synchronization2)+(VK_VERSION_1_1)": [
         {
-          "vuid": "VUID-VkSubmitInfo2KHR-flags-03885",
-          "text": " If the protected memory feature is not enabled, <code>flags</code> <strong class=\"purple\">must</strong> not include <code>VK_SUBMIT_PROTECTED_BIT_KHR</code>"
-        },
-        {
           "vuid": "VUID-VkSubmitInfo2KHR-flags-03886",
           "text": " If <code>flags</code> includes <code>VK_SUBMIT_PROTECTED_BIT_KHR</code>, all elements of <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> be protected command buffers"
         },
@@ -1794,6 +1800,12 @@
           "vuid": "VUID-vkQueueSubmit-pCommandBuffers-03220",
           "text": " If a command recorded into any element of <code>pCommandBuffers</code> was a <a href=\"#vkCmdBeginQuery\">vkCmdBeginQuery</a> whose <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <a href=\"#profiling-lock\">profiling lock</a> <strong class=\"purple\">must</strong> have been held continuously on the <code>VkDevice</code> that <code>queue</code> was retrieved from, throughout recording of those command buffers"
         }
+      ],
+      "(VK_VERSION_1_1)": [
+        {
+          "vuid": "VUID-vkQueueSubmit-queue-06448",
+          "text": " If <code>queue</code> was not created with <code>VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT</code>, there <strong class=\"purple\">must</strong> be no element of <code>pSubmits</code> that includes an <a href=\"#VkProtectedSubmitInfo\">VkProtectedSubmitInfo</a> structure in its <code>pNext</code> chain with <code>protectedSubmit</code> equal to <code>VK_TRUE</code>"
+        }
       ]
     },
     "VkSubmitInfo": {
@@ -2033,10 +2045,6 @@
     "VkProtectedSubmitInfo": {
       "(VK_VERSION_1_1)": [
         {
-          "vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01816",
-          "text": " If the protected memory feature is not enabled, <code>protectedSubmit</code> <strong class=\"purple\">must</strong> not be <code>VK_TRUE</code>"
-        },
-        {
           "vuid": "VUID-VkProtectedSubmitInfo-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO</code>"
         }
@@ -2224,11 +2232,11 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01820",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then each element of <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> be a protected command buffer"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, each element of <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> be a protected command buffer"
         },
         {
           "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01821",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then each element of <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> be an unprotected command buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, each element of <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> be an unprotected command buffer"
         }
       ],
       "(VK_EXT_transform_feedback)": [
@@ -6450,7 +6458,7 @@
         },
         {
           "vuid": "VUID-VkRenderingInfoKHR-imageView-06070",
-          "text": " If neither the <code><a href=\"#VK_AMD_mixed_attachment_samples\">VK_AMD_mixed_attachment_samples</a></code> nor the <code><a href=\"#VK_NV_framebuffer_mixed_samples\">VK_NV_framebuffer_mixed_samples</a></code> extensions are enabled, <code>imageView</code> members of <code>pDepthAttachment</code>, <code>pStencilAttachment</code>, and elements of <code>pColorAttachments</code> that are not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> <strong class=\"purple\">must</strong> have been created with the same <code>sampleCount</code>"
+          "text": " If neither the <a href=\"#VK_AMD_mixed_attachment_samples\">VK_AMD_mixed_attachment_samples</a> nor the <a href=\"#VK_NV_framebuffer_mixed_samples\">VK_NV_framebuffer_mixed_samples</a> extensions are enabled, <code>imageView</code> members of <code>pDepthAttachment</code>, <code>pStencilAttachment</code>, and elements of <code>pColorAttachments</code> that are not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> <strong class=\"purple\">must</strong> have been created with the same <code>sampleCount</code>"
         },
         {
           "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06087",
@@ -7748,11 +7756,11 @@
       "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_QCOM_render_pass_shader_resolve)": [
         {
           "vuid": "VUID-VkRenderPassCreateInfo2-rasterizationSamples-04905",
-          "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if subpass has any input attachments, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then the sample count of the input attachments <strong class=\"purple\">must</strong> equal <code>rasterizationSamples</code>"
+          "text": " If the pipeline is being created with fragment shader state, and the <a href=\"#VK_QCOM_render_pass_shader_resolve\">VK_QCOM_render_pass_shader_resolve</a> extension is enabled, and if subpass has any input attachments, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then the sample count of the input attachments <strong class=\"purple\">must</strong> equal <code>rasterizationSamples</code>"
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo2-sampleShadingEnable-04906",
-          "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then <code>sampleShadingEnable</code> <strong class=\"purple\">must</strong> be false"
+          "text": " If the pipeline is being created with fragment shader state, and the <a href=\"#VK_QCOM_render_pass_shader_resolve\">VK_QCOM_render_pass_shader_resolve</a> extension is enabled, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then <code>sampleShadingEnable</code> <strong class=\"purple\">must</strong> be false"
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo2-flags-04907",
@@ -10116,7 +10124,7 @@
       "(VK_HUAWEI_subpass_shading)": [
         {
           "vuid": "VUID-VkSubpassShadingPipelineCreateInfoHUAWEI-subpass-04946",
-          "text": " <code>subpass</code> <strong class=\"purple\">must</strong> be created with VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI bind point"
+          "text": " <code>subpass</code> <strong class=\"purple\">must</strong> be created with <code>VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI</code> bind point"
         },
         {
           "vuid": "VUID-VkSubpassShadingPipelineCreateInfoHUAWEI-sType-sType",
@@ -10792,11 +10800,11 @@
       "(VK_QCOM_render_pass_shader_resolve)": [
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizationSamples-04899",
-          "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if subpass has any input attachments, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then the sample count of the input attachments <strong class=\"purple\">must</strong> equal <code>rasterizationSamples</code>"
+          "text": " If the pipeline is being created with fragment shader state, and the <a href=\"#VK_QCOM_render_pass_shader_resolve\">VK_QCOM_render_pass_shader_resolve</a> extension is enabled, and if subpass has any input attachments, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then the sample count of the input attachments <strong class=\"purple\">must</strong> equal <code>rasterizationSamples</code>"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-sampleShadingEnable-04900",
-          "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then <code>sampleShadingEnable</code> <strong class=\"purple\">must</strong> be false"
+          "text": " If the pipeline is being created with fragment shader state, and the <a href=\"#VK_QCOM_render_pass_shader_resolve\">VK_QCOM_render_pass_shader_resolve</a> extension is enabled, and if the subpass description contains <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then <code>sampleShadingEnable</code> <strong class=\"purple\">must</strong> be false"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-04901",
@@ -12586,7 +12594,7 @@
       "(VK_KHR_external_memory_fd)": [
         {
           "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01742",
-          "text": " If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the payload being imported was created"
+          "text": " If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the payload being imported was created"
         },
         {
           "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648",
@@ -12610,7 +12618,7 @@
         },
         {
           "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01743",
-          "text": " If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR</code> or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the payload being imported was created"
+          "text": " If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the payload being imported was created"
         },
         {
           "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00647",
@@ -13234,7 +13242,7 @@
         },
         {
           "vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-00674",
-          "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not be <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR</code>"
+          "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not be <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>"
         },
         {
           "vuid": "VUID-vkGetMemoryFdPropertiesKHR-device-parameter",
@@ -15388,7 +15396,7 @@
         },
         {
           "vuid": "VUID-VkImageViewCreateInfo-format-06415",
-          "text": " If the image <code>format</code> is one of the <a href=\"#formats-requiring-sampler-ycbcr-conversion\">formats that require a sampler Y&#8217;C<sub>B</sub>C<sub>R</sub> conversion</a>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkSamplerYcbcrConversionInfo\">VkSamplerYcbcrConversionInfo</a> structure with a conversion value other than VK_NULL_HANDLE"
+          "text": " If the image <code>format</code> is one of the <a href=\"#formats-requiring-sampler-ycbcr-conversion\">formats that require a sampler Y&#8217;C<sub>B</sub>C<sub>R</sub> conversion</a>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkSamplerYcbcrConversionInfo\">VkSamplerYcbcrConversionInfo</a> structure with a conversion value other than <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-VkImageViewCreateInfo-format-04714",
@@ -23028,11 +23036,11 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01805",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>image</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>image</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01806",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>image</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ]
     },
@@ -23152,11 +23160,11 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01807",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>image</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>image</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01808",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>image</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>image</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ]
     },
@@ -23230,11 +23238,11 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdClearAttachments-commandBuffer-02504",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then each attachment to be cleared <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, each attachment to be cleared <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdClearAttachments-commandBuffer-02505",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then each attachment to be cleared <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, each attachment to be cleared <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "(VK_VERSION_1_1,VK_KHR_multiview)": [
@@ -23352,11 +23360,11 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01811",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01812",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
         }
       ]
     },
@@ -23426,11 +23434,11 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01813",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01814",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
         }
       ]
     },
@@ -23438,15 +23446,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01822",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01823",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01824",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
         }
       ],
       "core": [
@@ -23536,15 +23544,15 @@
       "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-01822",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-01823",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-01824",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
         }
       ],
       "(VK_KHR_copy_commands2)": [
@@ -23658,15 +23666,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyImage-commandBuffer-01825",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyImage-commandBuffer-01826",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyImage-commandBuffer-01827",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "core": [
@@ -24042,15 +24050,15 @@
       "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-01825",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-01826",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-01827",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "(VK_KHR_copy_commands2)": [
@@ -24420,15 +24428,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01828",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01829",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01830",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "core": [
@@ -24652,15 +24660,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01831",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01832",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01833",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
         }
       ],
       "core": [
@@ -24894,15 +24902,15 @@
       "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-01828",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-01829",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-01830",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "(VK_KHR_copy_commands2)": [
@@ -25166,15 +25174,15 @@
       "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-01831",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-01832",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be a protected buffer"
         },
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-01833",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstBuffer</code> <strong class=\"purple\">must</strong> not be an unprotected buffer"
         }
       ],
       "(VK_KHR_copy_commands2)": [
@@ -25472,15 +25480,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdBlitImage-commandBuffer-01834",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-commandBuffer-01835",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-commandBuffer-01836",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "core": [
@@ -25744,15 +25752,15 @@
       "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-01834",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-01835",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-01836",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "(VK_KHR_copy_commands2)": [
@@ -26058,15 +26066,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdResolveImage-commandBuffer-01837",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdResolveImage-commandBuffer-01838",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdResolveImage-commandBuffer-01839",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "core": [
@@ -26466,15 +26474,15 @@
       "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-01837",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>srcImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-01838",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be a protected image"
         },
         {
           "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-01839",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, then <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, <code>dstImage</code> <strong class=\"purple\">must</strong> not be an unprotected image"
         }
       ],
       "(VK_KHR_copy_commands2)": [
@@ -27012,15 +27020,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDraw-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDraw-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
         },
         {
           "vuid": "VUID-vkCmdDraw-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDraw-commandBuffer-04617",
@@ -27430,15 +27438,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-04617",
@@ -27860,15 +27868,15 @@
       "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-04617",
@@ -28298,15 +28306,15 @@
       "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-04617",
@@ -28756,7 +28764,7 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02711",
@@ -29234,7 +29242,7 @@
       "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02711",
@@ -29690,7 +29698,7 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02711",
@@ -30172,7 +30180,7 @@
       "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02711",
@@ -30616,7 +30624,7 @@
       "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02646",
@@ -31102,7 +31110,7 @@
       "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         }
       ],
       "(VK_NV_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [
@@ -31532,7 +31540,7 @@
       "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02711",
@@ -31994,7 +32002,7 @@
       "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02711",
@@ -35088,15 +35096,15 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDispatch-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDispatch-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
         },
         {
           "vuid": "VUID-vkCmdDispatch-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDispatch-commandBuffer-04617",
@@ -35286,7 +35294,7 @@
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02711",
@@ -35496,15 +35504,15 @@
       "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
         },
         {
           "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDispatchBase-commandBuffer-04617",
@@ -35602,7 +35610,7 @@
         },
         {
           "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-04931",
-          "text": " This command must be called in a subpass with bind point VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI. No draw commands can be called in the same subpass. Only one vkCmdSubpassShadingHUAWEI command can be called in a subpass"
+          "text": " This command must be called in a subpass with bind point <code>VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI</code>. No draw commands can be called in the same subpass. Only one <a href=\"#vkCmdSubpassShadingHUAWEI\">vkCmdSubpassShadingHUAWEI</a> command can be called in a subpass"
         },
         {
           "vuid": "VUID-vkCmdSubpassShadingHUAWEI-commandBuffer-parameter",
@@ -35674,7 +35682,7 @@
       "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdSubpassShadingHUAWEI-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         }
       ],
       "(VK_HUAWEI_subpass_shading)+(VK_EXT_shader_image_atomic_int64)": [
@@ -36212,7 +36220,7 @@
       "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02970",
@@ -42102,7 +42110,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         }
       ],
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_shader_image_atomic_int64)": [
@@ -42416,7 +42424,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         }
       ],
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_image_atomic_int64)": [
@@ -42810,7 +42818,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-02707",
-          "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource accessed by the <a href=\"#VkPipeline\">VkPipeline</a> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
         }
       ],
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_image_atomic_int64)": [
@@ -47164,7 +47172,7 @@
         },
         {
           "vuid": "VUID-StandaloneSpirv-Location-04918",
-          "text": " The <code>Location</code> decorations <strong class=\"purple\">must</strong> not be used on the members of <code>OpVariable</code> with a structure type that is a block decorated with <code>Location</code>"
+          "text": " The <code>Location</code> decorations <strong class=\"purple\">must</strong> not be used on the members of <code>OpVariable</code> with a structure type that is decorated with <code>Location</code>"
         },
         {
           "vuid": "VUID-StandaloneSpirv-Location-04919",
diff --git a/registry/vk.xml b/registry/vk.xml
index af8373a..4995c6f 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -155,7 +155,7 @@
         <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 197</type>
+#define <name>VK_HEADER_VERSION</name> 198</type>
         <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, VK_HEADER_VERSION)</type>