Merge tag 'vulkan-1.1.102' into merge-vulkan-1.1.102

Change-Id: I855b72d6ad215ac36de119a30a50c433035911d0
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5529e60..2640891 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,8 +36,17 @@
 
 # --------------------------------------------------------------------------------------------------------------------------------
 
-install(DIRECTORY "${CMAKE_SOURCE_DIR}/include/vulkan" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(DIRECTORY "${CMAKE_SOURCE_DIR}/registry" DESTINATION ${CMAKE_INSTALL_DATADIR}/vulkan)
+# define exported targets for nested project builds to consume
+add_library(Vulkan-Headers INTERFACE)
+target_include_directories(Vulkan-Headers INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include")
+add_library(Vulkan::Headers ALIAS Vulkan-Headers)
+
+add_library(Vulkan-Registry INTERFACE)
+target_include_directories(Vulkan-Registry INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/registry")
+add_library(Vulkan::Registry ALIAS Vulkan-Registry)
+
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/registry" DESTINATION ${CMAKE_INSTALL_DATADIR}/vulkan)
 
 # uninstall target
 if(NOT TARGET uninstall)
diff --git a/README.md b/README.md
index 4744317..685e712 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Vulkan-Headers
 
-Vulkan Header files and API registry
+Vulkan header files and API registry
 
 ## Repository Content
 
@@ -16,3 +16,11 @@
 
 Please visit the appropriate project in the above list for obtaining additional information,
 asking questions, or opening issues.
+
+## Version Tagging Scheme
+
+Updates to the `Vulkan-Headers` repository which correspond to a new Vulkan specification release are tagged using the following format: `v<`_`version`_`>` (e.g., `v1.1.96`).
+
+**Note**: Marked version releases have undergone thorough testing but do not imply the same quality level as SDK tags. SDK tags follow the `sdk-<`_`version`_`>.<`_`patch`_`>` format (e.g., `sdk-1.1.92.0`).
+
+This scheme was adopted following the 1.1.96 Vulkan specification release.
diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h
index cf9d85a..62b5533 100644
--- a/include/vulkan/vulkan.h
+++ b/include/vulkan/vulkan.h
@@ -2,7 +2,7 @@
 #define VULKAN_H_ 1
 
 /*
-** Copyright (c) 2015-2018 The Khronos Group Inc.
+** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
@@ -38,13 +38,10 @@
 #include "vulkan_macos.h"
 #endif
 
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-#include <mir_toolkit/client_types.h>
-#include "vulkan_mir.h"
+#ifdef VK_USE_PLATFORM_METAL_EXT
+#include "vulkan_metal.h"
 #endif
 
-
 #ifdef VK_USE_PLATFORM_VI_NN
 #include "vulkan_vi.h"
 #endif
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 1683876..84783ed 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2018 The Khronos Group Inc.
+// Copyright (c) 2015-2019 The Khronos Group Inc.
 // 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -45,15 +45,27 @@
 #include <tuple>
 #include <type_traits>
 #include <vulkan/vulkan.h>
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
 # include <memory>
 # include <vector>
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif
+
 #if !defined(VULKAN_HPP_ASSERT)
 # include <cassert>
 # define VULKAN_HPP_ASSERT   assert
 #endif
 
+static_assert( VK_HEADER_VERSION ==  102 , "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
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+#  define VULKAN_HPP_TYPESAFE_CONVERSION
+# endif
+#endif
+
 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
 // which is an expression in a constructor initializer list.
@@ -66,20 +78,10 @@
 
 // Windows defines MemoryBarrier which is deprecated and collides
 // with the vk::MemoryBarrier struct.
-#ifdef MemoryBarrier
+#if defined(MemoryBarrier)
   #undef MemoryBarrier
 #endif
 
-static_assert( VK_HEADER_VERSION ==  90 , "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
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-#  define VULKAN_HPP_TYPESAFE_CONVERSION
-# endif
-#endif
-
 #if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
 # if defined(__clang__)
 #  if __has_feature(cxx_unrestricted_unions)
@@ -125,7 +127,6 @@
 # define VULKAN_HPP_CONSTEXPR constexpr
 #endif
 
-
 #if !defined(VULKAN_HPP_NAMESPACE)
 #define VULKAN_HPP_NAMESPACE vk
 #endif
@@ -136,6 +137,97 @@
 
 namespace VULKAN_HPP_NAMESPACE
 {
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+  template <typename T>
+  class ArrayProxy
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
+      : m_count(0)
+      , m_ptr(nullptr)
+    {}
+
+    ArrayProxy(T & ptr)
+      : m_count(1)
+      , m_ptr(&ptr)
+    {}
+
+    ArrayProxy(uint32_t count, T * ptr)
+      : m_count(count)
+      , m_ptr(ptr)
+    {}
+
+    template <size_t N>
+    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
+      : m_count(N)
+      , m_ptr(data.data())
+    {}
+
+    template <size_t N>
+    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
+      : m_count(N)
+      , m_ptr(data.data())
+    {}
+
+    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
+    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
+      : m_count(static_cast<uint32_t>(data.size()))
+      , m_ptr(data.data())
+    {}
+
+    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
+    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
+      : m_count(static_cast<uint32_t>(data.size()))
+      , m_ptr(data.data())
+    {}
+
+    ArrayProxy(std::initializer_list<T> const& data)
+      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
+      , m_ptr(data.begin())
+    {}
+
+    const T * begin() const
+    {
+      return m_ptr;
+    }
+
+    const T * end() const
+    {
+      return m_ptr + m_count;
+    }
+
+    const T & front() const
+    {
+      VULKAN_HPP_ASSERT(m_count && m_ptr);
+      return *m_ptr;
+    }
+
+    const T & back() const
+    {
+      VULKAN_HPP_ASSERT(m_count && m_ptr);
+      return *(m_ptr + m_count - 1);
+    }
+
+    bool empty() const
+    {
+      return (m_count == 0);
+    }
+
+    uint32_t size() const
+    {
+      return m_count;
+    }
+
+    T * data() const
+    {
+      return m_ptr;
+    }
+
+  private:
+    uint32_t  m_count;
+    T *       m_ptr;
+  };
+#endif
 
   template <typename FlagBitsType> struct FlagTraits
   {
@@ -265,7 +357,6 @@
     return flags ^ bit;
   }
 
-
   template <typename RefType>
   class Optional
   {
@@ -282,204 +373,6 @@
     RefType *m_ptr;
   };
 
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T>
-  class ArrayProxy
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
-      : m_count(0)
-      , m_ptr(nullptr)
-    {}
-
-    ArrayProxy(T & ptr)
-      : m_count(1)
-      , m_ptr(&ptr)
-    {}
-
-    ArrayProxy(uint32_t count, T * ptr)
-      : m_count(count)
-      , m_ptr(ptr)
-    {}
-
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    ArrayProxy(std::initializer_list<T> const& data)
-      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
-      , m_ptr(data.begin())
-    {}
-
-    const T * begin() const
-    {
-      return m_ptr;
-    }
-
-    const T * end() const
-    {
-      return m_ptr + m_count;
-    }
-
-    const T & front() const
-    {
-      VULKAN_HPP_ASSERT(m_count && m_ptr);
-      return *m_ptr;
-    }
-
-    const T & back() const
-    {
-      VULKAN_HPP_ASSERT(m_count && m_ptr);
-      return *(m_ptr + m_count - 1);
-    }
-
-    bool empty() const
-    {
-      return (m_count == 0);
-    }
-
-    uint32_t size() const
-    {
-      return m_count;
-    }
-
-    T * data() const
-    {
-      return m_ptr;
-    }
-
-  private:
-    uint32_t  m_count;
-    T *       m_ptr;
-  };
-#endif
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-
-  template <typename Type, typename Dispatch> class UniqueHandleTraits;
-
-  template <typename Type, typename Dispatch>
-  class UniqueHandle : public UniqueHandleTraits<Type,Dispatch>::deleter
-  {
-  private:
-    using Deleter = typename UniqueHandleTraits<Type,Dispatch>::deleter;
-  public:
-    explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
-      : Deleter( deleter)
-      , m_value( value )
-    {}
-
-    UniqueHandle( UniqueHandle const& ) = delete;
-
-    UniqueHandle( UniqueHandle && other )
-      : Deleter( std::move( static_cast<Deleter&>( other ) ) )
-      , m_value( other.release() )
-    {}
-
-    ~UniqueHandle()
-    {
-      if ( m_value ) this->destroy( m_value );
-    }
-
-    UniqueHandle & operator=( UniqueHandle const& ) = delete;
-
-    UniqueHandle & operator=( UniqueHandle && other )
-    {
-      reset( other.release() );
-      *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
-      return *this;
-    }
-
-    explicit operator bool() const
-    {
-      return m_value.operator bool();
-    }
-
-    Type const* operator->() const
-    {
-      return &m_value;
-    }
-
-    Type * operator->()
-    {
-      return &m_value;
-    }
-
-    Type const& operator*() const
-    {
-      return m_value;
-    }
-
-    Type & operator*()
-    {
-      return m_value;
-    }
-
-    const Type & get() const
-    {
-      return m_value;
-    }
-    
-    Type & get()
-    {
-      return m_value;
-    }
-
-    void reset( Type const& value = Type() )
-    {
-      if ( m_value != value )
-      {
-        if ( m_value ) this->destroy( m_value );
-        m_value = value;
-      }
-    }
-
-    Type release()
-    {
-      Type value = m_value;
-      m_value = nullptr;
-      return value;
-    }
-
-    void swap( UniqueHandle<Type,Dispatch> & rhs )
-    {
-      std::swap(m_value, rhs.m_value);
-      std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
-    }
-
-  private:
-    Type    m_value;
-  };
-
-  template <typename Type, typename Dispatch>
-  VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Dispatch> & lhs, UniqueHandle<Type,Dispatch> & rhs )
-  {
-    lhs.swap( rhs );
-  }
-#endif
-
-
-
   template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; };
 
   template <typename P, typename T>
@@ -598,1931 +491,1887 @@
     }
   };
 
-  enum class Result
-  {
-    eSuccess = VK_SUCCESS,
-    eNotReady = VK_NOT_READY,
-    eTimeout = VK_TIMEOUT,
-    eEventSet = VK_EVENT_SET,
-    eEventReset = VK_EVENT_RESET,
-    eIncomplete = VK_INCOMPLETE,
-    eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
-    eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
-    eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
-    eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
-    eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
-    eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
-    eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
-    eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
-    eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
-    eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
-    eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
-    eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
-    eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY,
-    eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY,
-    eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE,
-    eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
-    eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR,
-    eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
-    eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
-    eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
-    eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
-    eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
-    eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
-    eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
-    eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT,
-    eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT
-  };
+#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
+  template <typename Type, typename Dispatch> class UniqueHandleTraits;
 
-  VULKAN_HPP_INLINE std::string to_string(Result value)
+  template <typename Type, typename Dispatch>
+  class UniqueHandle : public UniqueHandleTraits<Type,Dispatch>::deleter
   {
-    switch (value)
-    {
-    case Result::eSuccess: return "Success";
-    case Result::eNotReady: return "NotReady";
-    case Result::eTimeout: return "Timeout";
-    case Result::eEventSet: return "EventSet";
-    case Result::eEventReset: return "EventReset";
-    case Result::eIncomplete: return "Incomplete";
-    case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory";
-    case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory";
-    case Result::eErrorInitializationFailed: return "ErrorInitializationFailed";
-    case Result::eErrorDeviceLost: return "ErrorDeviceLost";
-    case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed";
-    case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent";
-    case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent";
-    case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent";
-    case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver";
-    case Result::eErrorTooManyObjects: return "ErrorTooManyObjects";
-    case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported";
-    case Result::eErrorFragmentedPool: return "ErrorFragmentedPool";
-    case Result::eErrorOutOfPoolMemory: return "ErrorOutOfPoolMemory";
-    case Result::eErrorInvalidExternalHandle: return "ErrorInvalidExternalHandle";
-    case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR";
-    case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR";
-    case Result::eSuboptimalKHR: return "SuboptimalKHR";
-    case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR";
-    case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR";
-    case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT";
-    case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV";
-    case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
-    case Result::eErrorFragmentationEXT: return "ErrorFragmentationEXT";
-    case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT";
-    default: return "invalid";
-    }
-  }
-
-#ifndef VULKAN_HPP_NO_EXCEPTIONS
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class ErrorCategoryImpl : public std::error_category
-  {
-    public:
-    virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
-    virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-  VULKAN_HPP_INLINE const std::error_category& errorCategory()
-  {
-    static ErrorCategoryImpl instance;
-    return instance;
-  }
-
-  VULKAN_HPP_INLINE std::error_code make_error_code(Result e)
-  {
-    return std::error_code(static_cast<int>(e), errorCategory());
-  }
-
-  VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e)
-  {
-    return std::error_condition(static_cast<int>(e), errorCategory());
-  }
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class Error
-  {
-    public:
-    virtual ~Error() = default;
-
-    virtual const char* what() const noexcept = 0;
-  };
-
-  class LogicError : public Error, public std::logic_error
-  {
-    public:
-    explicit LogicError( const std::string& what )
-      : Error(), std::logic_error(what) {}
-    explicit LogicError( char const * what )
-      : Error(), std::logic_error(what) {}
-    virtual ~LogicError() = default;
-
-    virtual const char* what() const noexcept { return std::logic_error::what(); }
-  };
-
-  class SystemError : public Error, public std::system_error
-  {
-    public:
-    SystemError( std::error_code ec )
-      : Error(), std::system_error(ec) {}
-    SystemError( std::error_code ec, std::string const& what )
-      : Error(), std::system_error(ec, what) {}
-    SystemError( std::error_code ec, char const * what )
-      : Error(), std::system_error(ec, what) {}
-    SystemError( int ev, std::error_category const& ecat )
-      : Error(), std::system_error(ev, ecat) {}
-    SystemError( int ev, std::error_category const& ecat, std::string const& what)
-      : Error(), std::system_error(ev, ecat, what) {}
-    SystemError( int ev, std::error_category const& ecat, char const * what)
-      : Error(), std::system_error(ev, ecat, what) {}
-    virtual ~SystemError() = default;
-
-    virtual const char* what() const noexcept { return std::system_error::what(); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-  class OutOfHostMemoryError : public SystemError
-  {
+  private:
+    using Deleter = typename UniqueHandleTraits<Type,Dispatch>::deleter;
   public:
-    OutOfHostMemoryError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
-    OutOfHostMemoryError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
-  };
-  class OutOfDeviceMemoryError : public SystemError
-  {
-  public:
-    OutOfDeviceMemoryError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
-    OutOfDeviceMemoryError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
-  };
-  class InitializationFailedError : public SystemError
-  {
-  public:
-    InitializationFailedError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
-    InitializationFailedError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
-  };
-  class DeviceLostError : public SystemError
-  {
-  public:
-    DeviceLostError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
-    DeviceLostError( char const * message )
-      : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
-  };
-  class MemoryMapFailedError : public SystemError
-  {
-  public:
-    MemoryMapFailedError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
-    MemoryMapFailedError( char const * message )
-      : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
-  };
-  class LayerNotPresentError : public SystemError
-  {
-  public:
-    LayerNotPresentError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
-    LayerNotPresentError( char const * message )
-      : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
-  };
-  class ExtensionNotPresentError : public SystemError
-  {
-  public:
-    ExtensionNotPresentError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
-    ExtensionNotPresentError( char const * message )
-      : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
-  };
-  class FeatureNotPresentError : public SystemError
-  {
-  public:
-    FeatureNotPresentError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
-    FeatureNotPresentError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
-  };
-  class IncompatibleDriverError : public SystemError
-  {
-  public:
-    IncompatibleDriverError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
-    IncompatibleDriverError( char const * message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
-  };
-  class TooManyObjectsError : public SystemError
-  {
-  public:
-    TooManyObjectsError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
-    TooManyObjectsError( char const * message )
-      : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
-  };
-  class FormatNotSupportedError : public SystemError
-  {
-  public:
-    FormatNotSupportedError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
-    FormatNotSupportedError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
-  };
-  class FragmentedPoolError : public SystemError
-  {
-  public:
-    FragmentedPoolError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
-    FragmentedPoolError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
-  };
-  class OutOfPoolMemoryError : public SystemError
-  {
-  public:
-    OutOfPoolMemoryError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
-    OutOfPoolMemoryError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
-  };
-  class InvalidExternalHandleError : public SystemError
-  {
-  public:
-    InvalidExternalHandleError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
-    InvalidExternalHandleError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
-  };
-  class SurfaceLostKHRError : public SystemError
-  {
-  public:
-    SurfaceLostKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
-    SurfaceLostKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
-  };
-  class NativeWindowInUseKHRError : public SystemError
-  {
-  public:
-    NativeWindowInUseKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
-    NativeWindowInUseKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
-  };
-  class OutOfDateKHRError : public SystemError
-  {
-  public:
-    OutOfDateKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
-    OutOfDateKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
-  };
-  class IncompatibleDisplayKHRError : public SystemError
-  {
-  public:
-    IncompatibleDisplayKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
-    IncompatibleDisplayKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
-  };
-  class ValidationFailedEXTError : public SystemError
-  {
-  public:
-    ValidationFailedEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
-    ValidationFailedEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
-  };
-  class InvalidShaderNVError : public SystemError
-  {
-  public:
-    InvalidShaderNVError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
-    InvalidShaderNVError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
-  };
-  class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
-  {
-  public:
-    InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
-    InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
-  };
-  class FragmentationEXTError : public SystemError
-  {
-  public:
-    FragmentationEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {}
-    FragmentationEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {}
-  };
-  class NotPermittedEXTError : public SystemError
-  {
-  public:
-    NotPermittedEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
-    NotPermittedEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
-  };
-
-  VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
-  {
-    switch ( result )
-    {
-    case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError ( message );
-    case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError ( message );
-    case Result::eErrorInitializationFailed: throw InitializationFailedError ( message );
-    case Result::eErrorDeviceLost: throw DeviceLostError ( message );
-    case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError ( message );
-    case Result::eErrorLayerNotPresent: throw LayerNotPresentError ( message );
-    case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError ( message );
-    case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError ( message );
-    case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError ( message );
-    case Result::eErrorTooManyObjects: throw TooManyObjectsError ( message );
-    case Result::eErrorFormatNotSupported: throw FormatNotSupportedError ( message );
-    case Result::eErrorFragmentedPool: throw FragmentedPoolError ( message );
-    case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError ( message );
-    case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError ( message );
-    case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError ( message );
-    case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError ( message );
-    case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError ( message );
-    case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message );
-    case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message );
-    case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message );
-    case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError ( message );
-    case Result::eErrorFragmentationEXT: throw FragmentationEXTError ( message );
-    case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message );
-    default: throw SystemError( make_error_code( result ) );
-    }
-  }
-#endif
-} // namespace VULKAN_HPP_NAMESPACE
-
-namespace std
-{
-  template <>
-  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
-  {};
-}
-
-namespace VULKAN_HPP_NAMESPACE
-{
-
-  template <typename T>
-  struct ResultValue
-  {
-    ResultValue( Result r, T & v )
-      : result( r )
-      , value( v )
+    explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
+      : Deleter( deleter)
+      , m_value( value )
     {}
 
-    ResultValue( Result r, T && v )
-      : result( r )
-      , value( std::move( v ) )
+    UniqueHandle( UniqueHandle const& ) = delete;
+
+    UniqueHandle( UniqueHandle && other )
+      : Deleter( std::move( static_cast<Deleter&>( other ) ) )
+      , m_value( other.release() )
     {}
 
-    Result  result;
-    T       value;
+    ~UniqueHandle()
+    {
+      if ( m_value ) this->destroy( m_value );
+    }
 
-    operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); }
+    UniqueHandle & operator=( UniqueHandle const& ) = delete;
+
+    UniqueHandle & operator=( UniqueHandle && other )
+    {
+      reset( other.release() );
+      *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
+      return *this;
+    }
+
+    explicit operator bool() const
+    {
+      return m_value.operator bool();
+    }
+
+    Type const* operator->() const
+    {
+      return &m_value;
+    }
+
+    Type * operator->()
+    {
+      return &m_value;
+    }
+
+    Type const& operator*() const
+    {
+      return m_value;
+    }
+
+    Type & operator*()
+    {
+      return m_value;
+    }
+
+    const Type & get() const
+    {
+      return m_value;
+    }
+    
+    Type & get()
+    {
+      return m_value;
+    }
+
+    void reset( Type const& value = Type() )
+    {
+      if ( m_value != value )
+      {
+        if ( m_value ) this->destroy( m_value );
+        m_value = value;
+      }
+    }
+
+    Type release()
+    {
+      Type value = m_value;
+      m_value = nullptr;
+      return value;
+    }
+
+    void swap( UniqueHandle<Type,Dispatch> & rhs )
+    {
+      std::swap(m_value, rhs.m_value);
+      std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
+    }
+
+  private:
+    Type    m_value;
   };
 
-  template <typename T>
-  struct ResultValueType
+  template <typename Type, typename Dispatch>
+  VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Dispatch> & lhs, UniqueHandle<Type,Dispatch> & rhs )
   {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef ResultValue<T>  type;
-#else
-    typedef T               type;
+    lhs.swap( rhs );
+  }
 #endif
-  };
 
-  template <>
-  struct ResultValueType<void>
+  class DispatchLoaderStatic
   {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef Result type;
-#else
-    typedef void   type;
-#endif
-  };
-
-  VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return result;
-#else
-    if ( result != Result::eSuccess )
+  public:
+    VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance ) const
     {
-      throwResultException( result, message );
+      return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
     }
-#endif
-  }
 
-  template <typename T>
-  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return ResultValue<T>( result, data );
-#else
-    if ( result != Result::eSuccess )
+    VkResult vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const
     {
-      throwResultException( result, message );
+      return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
     }
-    return std::move( data );
-#endif
-  }
 
-  VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
-#else
-    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    VkResult vkEnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const
     {
-      throwResultException( result, message );
+      return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
     }
-#endif
-    return result;
-  }
 
-  template <typename T>
-  VULKAN_HPP_INLINE ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
-#else
-    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    VkResult vkEnumerateInstanceVersion( uint32_t* pApiVersion ) const
     {
-      throwResultException( result, message );
+      return ::vkEnumerateInstanceVersion( pApiVersion );
     }
-#endif
-    return ResultValue<T>( result, data );
-  }
 
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename T, typename D>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T,D>>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits<T,D>::deleter const& deleter )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(data, deleter) );
-#else
-    if ( result != Result::eSuccess )
+    VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo ) const
     {
-      throwResultException( result, message );
+      return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
     }
-    return UniqueHandle<T,D>(data, deleter);
-#endif
-  }
-#endif
 
-class DispatchLoaderStatic
-{
-public:
-  VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex  ) const
-  {
-    return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex);
-  }
-  VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex  ) const
-  {
-    return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex);
-  }
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
-  VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display  ) const
-  {
-    return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display);
-  }
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
-  VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers  ) const
-  {
-    return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers);
-  }
-  VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets  ) const
-  {
-    return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets);
-  }
-  VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory  ) const
-  {
-    return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory);
-  }
-  VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo  ) const
-  {
-    return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo);
-  }
-  VkResult vkBindAccelerationStructureMemoryNVX( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos  ) const
-  {
-    return ::vkBindAccelerationStructureMemoryNVX( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset  ) const
-  {
-    return ::vkBindBufferMemory( device, buffer, memory, memoryOffset);
-  }
-  VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset  ) const
-  {
-    return ::vkBindImageMemory( device, image, memory, memoryOffset);
-  }
-  VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos);
-  }
-  void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin  ) const
-  {
-    return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin);
-  }
-  void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo);
-  }
-  void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags  ) const
-  {
-    return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags);
-  }
-  void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index  ) const
-  {
-    return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index);
-  }
-  void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents  ) const
-  {
-    return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents);
-  }
-  void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo  ) const
-  {
-    return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-  }
-  void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets  ) const
-  {
-    return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-  }
-  void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets  ) const
-  {
-    return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-  }
-  void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType  ) const
-  {
-    return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType);
-  }
-  void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline  ) const
-  {
-    return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline);
-  }
-  void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout  ) const
-  {
-    return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout);
-  }
-  void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes  ) const
-  {
-    return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-  }
-  void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets  ) const
-  {
-    return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-  }
-  void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter  ) const
-  {
-    return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-  }
-  void vkCmdBuildAccelerationStructureNVX( VkCommandBuffer commandBuffer, VkAccelerationStructureTypeNVX type, uint32_t instanceCount, VkBuffer instanceData, VkDeviceSize instanceOffset, uint32_t geometryCount, const VkGeometryNVX* pGeometries, VkBuildAccelerationStructureFlagsNVX flags, VkBool32 update, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkBuffer scratch, VkDeviceSize scratchOffset  ) const
-  {
-    return ::vkCmdBuildAccelerationStructureNVX( commandBuffer, type, instanceCount, instanceData, instanceOffset, geometryCount, pGeometries, flags, update, dst, src, scratch, scratchOffset);
-  }
-  void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects  ) const
-  {
-    return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-  }
-  void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges  ) const
-  {
-    return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-  }
-  void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges  ) const
-  {
-    return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-  }
-  void vkCmdCopyAccelerationStructureNVX( VkCommandBuffer commandBuffer, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkCopyAccelerationStructureModeNVX mode  ) const
-  {
-    return ::vkCmdCopyAccelerationStructureNVX( commandBuffer, dst, src, mode);
-  }
-  void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-  }
-  void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-  }
-  void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-  }
-  void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-  }
-  void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags  ) const
-  {
-    return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-  }
-  void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo  ) const
-  {
-    return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo);
-  }
-  void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdDebugMarkerEndEXT( commandBuffer);
-  }
-  void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo  ) const
-  {
-    return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo);
-  }
-  void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ  ) const
-  {
-    return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ);
-  }
-  void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ  ) const
-  {
-    return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-  }
-  void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ  ) const
-  {
-    return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-  }
-  void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset  ) const
-  {
-    return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset);
-  }
-  void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance  ) const
-  {
-    return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-  }
-  void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance  ) const
-  {
-    return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-  }
-  void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride);
-  }
-  void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride);
-  }
-  void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride  ) const
-  {
-    return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-  }
-  void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride);
-  }
-  void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask  ) const
-  {
-    return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask);
-  }
-  void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdEndConditionalRenderingEXT( commandBuffer);
-  }
-  void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer);
-  }
-  void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query  ) const
-  {
-    return ::vkCmdEndQuery( commandBuffer, queryPool, query);
-  }
-  void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index  ) const
-  {
-    return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index);
-  }
-  void vkCmdEndRenderPass( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdEndRenderPass( commandBuffer);
-  }
-  void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo  ) const
-  {
-    return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo);
-  }
-  void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets  ) const
-  {
-    return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-  }
-  void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers  ) const
-  {
-    return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers);
-  }
-  void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data  ) const
-  {
-    return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data);
-  }
-  void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo);
-  }
-  void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents  ) const
-  {
-    return ::vkCmdNextSubpass( commandBuffer, contents);
-  }
-  void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo  ) const
-  {
-    return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-  }
-  void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers  ) const
-  {
-    return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-  }
-  void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo  ) const
-  {
-    return ::vkCmdProcessCommandsNVX( commandBuffer, pProcessCommandsInfo);
-  }
-  void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues  ) const
-  {
-    return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues);
-  }
-  void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites  ) const
-  {
-    return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-  }
-  void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData  ) const
-  {
-    return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-  }
-  void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo  ) const
-  {
-    return ::vkCmdReserveSpaceForCommandsNVX( commandBuffer, pReserveSpaceInfo);
-  }
-  void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask  ) const
-  {
-    return ::vkCmdResetEvent( commandBuffer, event, stageMask);
-  }
-  void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount  ) const
-  {
-    return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount);
-  }
-  void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions  ) const
-  {
-    return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-  }
-  void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4]  ) const
-  {
-    return ::vkCmdSetBlendConstants( commandBuffer, blendConstants);
-  }
-  void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker  ) const
-  {
-    return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker);
-  }
-  void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders  ) const
-  {
-    return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
-  }
-  void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor  ) const
-  {
-    return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-  }
-  void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds  ) const
-  {
-    return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds);
-  }
-  void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask  ) const
-  {
-    return ::vkCmdSetDeviceMask( commandBuffer, deviceMask);
-  }
-  void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask  ) const
-  {
-    return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask);
-  }
-  void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles  ) const
-  {
-    return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
-  }
-  void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask  ) const
-  {
-    return ::vkCmdSetEvent( commandBuffer, event, stageMask);
-  }
-  void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors  ) const
-  {
-    return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
-  }
-  void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth  ) const
-  {
-    return ::vkCmdSetLineWidth( commandBuffer, lineWidth);
-  }
-  void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo  ) const
-  {
-    return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo);
-  }
-  void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors  ) const
-  {
-    return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors);
-  }
-  void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask  ) const
-  {
-    return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask);
-  }
-  void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference  ) const
-  {
-    return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference);
-  }
-  void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask  ) const
-  {
-    return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask);
-  }
-  void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports  ) const
-  {
-    return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports);
-  }
-  void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes  ) const
-  {
-    return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
-  }
-  void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings  ) const
-  {
-    return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings);
-  }
-  void vkCmdTraceRaysNVX( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, uint32_t width, uint32_t height  ) const
-  {
-    return ::vkCmdTraceRaysNVX( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, width, height);
-  }
-  void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData  ) const
-  {
-    return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-  }
-  void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers  ) const
-  {
-    return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-  }
-  void vkCmdWriteAccelerationStructurePropertiesNVX( VkCommandBuffer commandBuffer, VkAccelerationStructureNVX accelerationStructure, VkQueryType queryType, VkQueryPool queryPool, uint32_t query  ) const
-  {
-    return ::vkCmdWriteAccelerationStructurePropertiesNVX( commandBuffer, accelerationStructure, queryType, queryPool, query);
-  }
-  void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker  ) const
-  {
-    return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
-  }
-  void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query  ) const
-  {
-    return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query);
-  }
-  VkResult vkCompileDeferredNVX( VkDevice device, VkPipeline pipeline, uint32_t shader  ) const
-  {
-    return ::vkCompileDeferredNVX( device, pipeline, shader);
-  }
-  VkResult vkCreateAccelerationStructureNVX( VkDevice device, const VkAccelerationStructureCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNVX* pAccelerationStructure  ) const
-  {
-    return ::vkCreateAccelerationStructureNVX( device, pCreateInfo, pAllocator, pAccelerationStructure);
-  }
+    void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin ) const
+    {
+      return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
+    }
+
+    void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+    }
+
+    void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const
+    {
+      return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
+    }
+
+    void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
+    {
+      return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
+    }
+
+    void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents ) const
+    {
+      return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
+    }
+
+    void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo ) const
+    {
+      return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+    }
+
+    void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
+    {
+      return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+    }
+
+    void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const
+    {
+      return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
+    }
+
+    void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const
+    {
+      return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
+    }
+
+    void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const
+    {
+      return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
+    }
+
+    void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const
+    {
+      return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
+    }
+
+    void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes ) const
+    {
+      return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
+    }
+
+    void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets ) const
+    {
+      return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
+    }
+
+    void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter ) const
+    {
+      return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
+    }
+
+    void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset ) const
+    {
+      return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
+    }
+
+    void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects ) const
+    {
+      return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
+    }
+
+    void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const
+    {
+      return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
+    }
+
+    void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const
+    {
+      return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
+    }
+
+    void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode ) const
+    {
+      return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
+    }
+
+    void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions ) const
+    {
+      return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
+    }
+
+    void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const
+    {
+      return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions ) const
+    {
+      return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const
+    {
+      return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
+    }
+
+    void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags ) const
+    {
+      return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
+    }
+
+    void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const
+    {
+      return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
+    }
+
+    void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdDebugMarkerEndEXT( commandBuffer );
+    }
+
+    void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const
+    {
+      return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
+    }
+
+    void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
+    {
+      return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
+    }
+
+    void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
+    {
+      return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+    }
+
+    void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
+    {
+      return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+    }
+
+    void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const
+    {
+      return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
+    }
+
+    void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
+    {
+      return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
+    }
+
+    void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const
+    {
+      return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+    }
+
+    void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride ) const
+    {
+      return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
+    }
+
+    void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const
+    {
+      return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
+    }
+
+    void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
+    }
+
+    void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
+    }
+
+    void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const
+    {
+      return ::vkCmdEndQuery( commandBuffer, queryPool, query );
+    }
+
+    void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const
+    {
+      return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
+    }
+
+    void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdEndRenderPass( commandBuffer );
+    }
+
+    void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const
+    {
+      return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
+    }
+
+    void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
+    {
+      return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+    }
+
+    void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const
+    {
+      return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
+    }
+
+    void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const
+    {
+      return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
+    }
+
+    void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+    }
+
+    void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const
+    {
+      return ::vkCmdNextSubpass( commandBuffer, contents );
+    }
+
+    void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const
+    {
+      return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+    }
+
+    void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const
+    {
+      return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
+    }
+
+    void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const
+    {
+      return ::vkCmdProcessCommandsNVX( commandBuffer, pProcessCommandsInfo );
+    }
+
+    void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const
+    {
+      return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
+    }
+
+    void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites ) const
+    {
+      return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
+    }
+
+    void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData ) const
+    {
+      return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
+    }
+
+    void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const
+    {
+      return ::vkCmdReserveSpaceForCommandsNVX( commandBuffer, pReserveSpaceInfo );
+    }
+
+    void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const
+    {
+      return ::vkCmdResetEvent( commandBuffer, event, stageMask );
+    }
+
+    void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const
+    {
+      return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
+    }
+
+    void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions ) const
+    {
+      return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const
+    {
+      return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
+    }
+
+    void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker ) const
+    {
+      return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
+    }
+
+    void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders ) const
+    {
+      return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
+    }
+
+    void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const
+    {
+      return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+    }
+
+    void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const
+    {
+      return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
+    }
+
+    void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const
+    {
+      return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
+    }
+
+    void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const
+    {
+      return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
+    }
+
+    void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles ) const
+    {
+      return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
+    }
+
+    void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const
+    {
+      return ::vkCmdSetEvent( commandBuffer, event, stageMask );
+    }
+
+    void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors ) const
+    {
+      return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
+    }
+
+    void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const
+    {
+      return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
+    }
+
+    void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo ) const
+    {
+      return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
+    }
+
+    void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors ) const
+    {
+      return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
+    }
+
+    void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const
+    {
+      return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
+    }
+
+    void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const
+    {
+      return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
+    }
+
+    void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const
+    {
+      return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
+    }
+
+    void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports ) const
+    {
+      return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
+    }
+
+    void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes ) const
+    {
+      return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
+    }
+
+    void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings ) const
+    {
+      return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
+    }
+
+    void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth ) const
+    {
+      return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
+    }
+
+    void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData ) const
+    {
+      return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
+    }
+
+    void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const
+    {
+      return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
+    }
+
+    void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const
+    {
+      return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+    }
+
+    void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const
+    {
+      return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
+    }
+
+    void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) const
+    {
+      return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
+    }
+
+    VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkEndCommandBuffer( commandBuffer );
+    }
+
+    VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const
+    {
+      return ::vkResetCommandBuffer( commandBuffer, flags );
+    }
+
+    VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex ) const
+    {
+      return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
+    }
+
+    VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex ) const
+    {
+      return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
+    }
+
+    VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const
+    {
+      return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
+    }
+
+    VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets ) const
+    {
+      return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
+    }
+
+    VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory ) const
+    {
+      return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
+    }
+
+    VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos ) const
+    {
+      return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const
+    {
+      return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
+    }
+
+    VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const
+    {
+      return ::vkBindImageMemory( device, image, memory, memoryOffset );
+    }
+
+    VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const
+    {
+      return ::vkCompileDeferredNV( device, pipeline, shader );
+    }
+
+    VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure ) const
+    {
+      return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
+    }
+
+    VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer ) const
+    {
+      return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
+    }
+
+    VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView ) const
+    {
+      return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
+    }
+
+    VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool ) const
+    {
+      return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
+    }
+
+    VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
+    {
+      return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool ) const
+    {
+      return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
+    }
+
+    VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout ) const
+    {
+      return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
+    }
+
+    VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const
+    {
+      return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+    }
+
+    VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const
+    {
+      return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+    }
+
+    VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent ) const
+    {
+      return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
+    }
+
+    VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
+    {
+      return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
+    }
+
+    VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer ) const
+    {
+      return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
+    }
+
+    VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
+    {
+      return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage ) const
+    {
+      return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
+    }
+
+    VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView ) const
+    {
+      return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
+    }
+
+    VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const
+    {
+      return ::vkCreateIndirectCommandsLayoutNVX( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
+    }
+
+    VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable ) const
+    {
+      return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable );
+    }
+
+    VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache ) const
+    {
+      return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
+    }
+
+    VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout ) const
+    {
+      return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
+    }
+
+    VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool ) const
+    {
+      return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
+    }
+
+    VkResult vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
+    {
+      return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const
+    {
+      return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
+    }
+
+    VkResult vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const
+    {
+      return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
+    }
+
+    VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler ) const
+    {
+      return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
+    }
+
+    VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const
+    {
+      return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
+    }
+
+    VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const
+    {
+      return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
+    }
+
+    VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore ) const
+    {
+      return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
+    }
+
+    VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule ) const
+    {
+      return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
+    }
+
+    VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains ) const
+    {
+      return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
+    }
+
+    VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain ) const
+    {
+      return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
+    }
+
+    VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache ) const
+    {
+      return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
+    }
+
+    VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo ) const
+    {
+      return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
+    }
+
+    VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo ) const
+    {
+      return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
+    }
+
+    void vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
+    }
+
+    void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyBuffer( device, buffer, pAllocator );
+    }
+
+    void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyBufferView( device, bufferView, pAllocator );
+    }
+
+    void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyCommandPool( device, commandPool, pAllocator );
+    }
+
+    void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
+    }
+
+    void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
+    }
+
+    void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
+    }
+
+    void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
+    }
+
+    void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDevice( device, pAllocator );
+    }
+
+    void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyEvent( device, event, pAllocator );
+    }
+
+    void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyFence( device, fence, pAllocator );
+    }
+
+    void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
+    }
+
+    void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyImage( device, image, pAllocator );
+    }
+
+    void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyImageView( device, imageView, pAllocator );
+    }
+
+    void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyIndirectCommandsLayoutNVX( device, indirectCommandsLayout, pAllocator );
+    }
+
+    void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyObjectTableNVX( device, objectTable, pAllocator );
+    }
+
+    void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyPipeline( device, pipeline, pAllocator );
+    }
+
+    void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
+    }
+
+    void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
+    }
+
+    void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyQueryPool( device, queryPool, pAllocator );
+    }
+
+    void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyRenderPass( device, renderPass, pAllocator );
+    }
+
+    void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySampler( device, sampler, pAllocator );
+    }
+
+    void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
+    }
+
+    void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
+    }
+
+    void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySemaphore( device, semaphore, pAllocator );
+    }
+
+    void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
+    }
+
+    void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
+    }
+
+    void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
+    }
+
+    VkResult vkDeviceWaitIdle( VkDevice device ) const
+    {
+      return ::vkDeviceWaitIdle( device );
+    }
+
+    VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo ) const
+    {
+      return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
+    }
+
+    VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const
+    {
+      return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+    }
+
+    void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const
+    {
+      return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
+    }
+
+    VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets ) const
+    {
+      return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
+    }
+
+    void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkFreeMemory( device, memory, pAllocator );
+    }
+
+    VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData ) const
+    {
+      return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
+    }
+
+    void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements ) const
+    {
+      return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
+    }
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const
+    {
+      return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
+    }
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-  VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer  ) const
-  {
-    return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer);
-  }
-  VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView  ) const
-  {
-    return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView);
-  }
-  VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool  ) const
-  {
-    return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool);
-  }
-  VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines  ) const
-  {
-    return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-  }
-  VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback  ) const
-  {
-    return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback);
-  }
-  VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger  ) const
-  {
-    return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger);
-  }
-  VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool  ) const
-  {
-    return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool);
-  }
-  VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout  ) const
-  {
-    return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout);
-  }
-  VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate  ) const
-  {
-    return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-  }
-  VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate  ) const
-  {
-    return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-  }
-  VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice  ) const
-  {
-    return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice);
-  }
-  VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode  ) const
-  {
-    return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode);
-  }
-  VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
-  VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent  ) const
-  {
-    return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent);
-  }
-  VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence  ) const
-  {
-    return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence);
-  }
-  VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer  ) const
-  {
-    return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer);
-  }
-  VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines  ) const
-  {
-    return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-  }
+
+    VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo ) const
+    {
+      return ::vkGetBufferDeviceAddressEXT( device, pInfo );
+    }
+
+    void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements ) const
+    {
+      return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
+    }
+
+    void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+    }
+
+    VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation ) const
+    {
+      return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
+    }
+
+    void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const
+    {
+      return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
+    }
+
+    void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const
+    {
+      return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
+    }
+
+    void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const
+    {
+      return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+    }
+
+    void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const
+    {
+      return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+    }
+
+    VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities ) const
+    {
+      return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
+    }
+
+    VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes ) const
+    {
+      return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
+    }
+
+    void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes ) const
+    {
+      return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
+    }
+
+    PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char* pName ) const
+    {
+      return ::vkGetDeviceProcAddr( device, pName );
+    }
+
+    void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue ) const
+    {
+      return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
+    }
+
+    void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue ) const
+    {
+      return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
+    }
+
+    VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const
+    {
+      return ::vkGetEventStatus( device, event );
+    }
+
+    VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const
+    {
+      return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
+    }
+
+    VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const
+    {
+      return ::vkGetFenceStatus( device, fence );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
+    {
+      return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties ) const
+    {
+      return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
+    }
+
+    void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements ) const
+    {
+      return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
+    }
+
+    void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements ) const
+    {
+      return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const
+    {
+      return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const
+    {
+      return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout ) const
+    {
+      return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
+    }
+
+    uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX* pInfo ) const
+    {
+      return ::vkGetImageViewHandleNVX( device, pInfo );
+    }
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer ) const
+    {
+      return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
+    }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const
+    {
+      return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
+    }
+
+    VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties ) const
+    {
+      return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
+    }
+
+    VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const
+    {
+      return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
+    {
+      return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const
+    {
+      return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const
+    {
+      return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings ) const
+    {
+      return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
+    }
+
+    VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData ) const
+    {
+      return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
+    }
+
+    VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const
+    {
+      return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
+    }
+
+    VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData ) const
+    {
+      return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
+    }
+
+    VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const
+    {
+      return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
+    }
+
+    void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity ) const
+    {
+      return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
+    }
+
+    VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const
+    {
+      return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
+    {
+      return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const
+    {
+      return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
+    }
+
+    VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const
+    {
+      return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
+    }
+
+    VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages ) const
+    {
+      return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
+    }
+
+    VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const
+    {
+      return ::vkGetSwapchainStatusKHR( device, swapchain );
+    }
+
+    VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const
+    {
+      return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
+    }
+
+    VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo ) const
+    {
+      return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const
+    {
+      return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const
+    {
+      return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const
+    {
+      return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const
+    {
+      return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+    }
+
+    VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData ) const
+    {
+      return ::vkMapMemory( device, memory, offset, size, flags, ppData );
+    }
+
+    VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches ) const
+    {
+      return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
+    }
+
+    VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches ) const
+    {
+      return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
+    }
+
+    VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
+    {
+      return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
+    {
+      return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const
+    {
+      return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices );
+    }
+
+    VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const
+    {
+      return ::vkResetCommandPool( device, commandPool, flags );
+    }
+
+    VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const
+    {
+      return ::vkResetDescriptorPool( device, descriptorPool, flags );
+    }
+
+    VkResult vkResetEvent( VkDevice device, VkEvent event ) const
+    {
+      return ::vkResetEvent( device, event );
+    }
+
+    VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences ) const
+    {
+      return ::vkResetFences( device, fenceCount, pFences );
+    }
+
+    VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo ) const
+    {
+      return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
+    }
+
+    VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo ) const
+    {
+      return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
+    }
+
+    VkResult vkSetEvent( VkDevice device, VkEvent event ) const
+    {
+      return ::vkSetEvent( device, event );
+    }
+
+    void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata ) const
+    {
+      return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
+    }
+
+    void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const
+    {
+      return ::vkTrimCommandPool( device, commandPool, flags );
+    }
+
+    void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const
+    {
+      return ::vkTrimCommandPoolKHR( device, commandPool, flags );
+    }
+
+    void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const
+    {
+      return ::vkUnmapMemory( device, memory );
+    }
+
+    VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const
+    {
+      return ::vkUnregisterObjectsNVX( device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices );
+    }
+
+    void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const
+    {
+      return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const
+    {
+      return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies ) const
+    {
+      return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
+    }
+
+    VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout ) const
+    {
+      return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
+    }
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback ) const
+    {
+      return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
+    }
+
+    VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger ) const
+    {
+      return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
+    }
+
+    VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
 #ifdef VK_USE_PLATFORM_IOS_MVK
-  VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
-  VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage  ) const
-  {
-    return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage);
-  }
-#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
-  VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface);
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
-  VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView  ) const
-  {
-    return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView);
-  }
-  VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout  ) const
-  {
-    return ::vkCreateIndirectCommandsLayoutNVX( device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-  }
-  VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance  ) const
-  {
-    return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance);
-  }
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 #ifdef VK_USE_PLATFORM_MACOS_MVK
-  VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  VkResult vkCreateMirSurfaceKHR( VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateMirSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-  VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable  ) const
-  {
-    return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable);
-  }
-  VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache  ) const
-  {
-    return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache);
-  }
-  VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout  ) const
-  {
-    return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout);
-  }
-  VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool  ) const
-  {
-    return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool);
-  }
-  VkResult vkCreateRaytracingPipelinesNVX( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRaytracingPipelineCreateInfoNVX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines  ) const
-  {
-    return ::vkCreateRaytracingPipelinesNVX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-  }
-  VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass  ) const
-  {
-    return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass);
-  }
-  VkResult vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass  ) const
-  {
-    return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass);
-  }
-  VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler  ) const
-  {
-    return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler);
-  }
-  VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion  ) const
-  {
-    return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion);
-  }
-  VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion  ) const
-  {
-    return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion);
-  }
-  VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore  ) const
-  {
-    return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore);
-  }
-  VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule  ) const
-  {
-    return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule);
-  }
-  VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains  ) const
-  {
-    return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-  }
-  VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain  ) const
-  {
-    return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain);
-  }
-  VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache  ) const
-  {
-    return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache);
-  }
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    VkResult vkCreateMetalSurfaceEXT( VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
 #ifdef VK_USE_PLATFORM_VI_NN
-  VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_VI_NN*/
+
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VK_USE_PLATFORM_XCB_KHR
-  VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
+
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-  VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
-  VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo  ) const
-  {
-    return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo);
-  }
-  VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo  ) const
-  {
-    return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo);
-  }
-  void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage  ) const
-  {
-    return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
-  }
-  void vkDestroyAccelerationStructureNVX( VkDevice device, VkAccelerationStructureNVX accelerationStructure, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyAccelerationStructureNVX( device, accelerationStructure, pAllocator);
-  }
-  void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyBuffer( device, buffer, pAllocator);
-  }
-  void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyBufferView( device, bufferView, pAllocator);
-  }
-  void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyCommandPool( device, commandPool, pAllocator);
-  }
-  void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator);
-  }
-  void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator);
-  }
-  void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator);
-  }
-  void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator);
-  }
-  void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator);
-  }
-  void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator);
-  }
-  void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDevice( device, pAllocator);
-  }
-  void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyEvent( device, event, pAllocator);
-  }
-  void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyFence( device, fence, pAllocator);
-  }
-  void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyFramebuffer( device, framebuffer, pAllocator);
-  }
-  void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyImage( device, image, pAllocator);
-  }
-  void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyImageView( device, imageView, pAllocator);
-  }
-  void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyIndirectCommandsLayoutNVX( device, indirectCommandsLayout, pAllocator);
-  }
-  void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyInstance( instance, pAllocator);
-  }
-  void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyObjectTableNVX( device, objectTable, pAllocator);
-  }
-  void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyPipeline( device, pipeline, pAllocator);
-  }
-  void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator);
-  }
-  void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator);
-  }
-  void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyQueryPool( device, queryPool, pAllocator);
-  }
-  void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyRenderPass( device, renderPass, pAllocator);
-  }
-  void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySampler( device, sampler, pAllocator);
-  }
-  void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator);
-  }
-  void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator);
-  }
-  void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySemaphore( device, semaphore, pAllocator);
-  }
-  void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyShaderModule( device, shaderModule, pAllocator);
-  }
-  void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySurfaceKHR( instance, surface, pAllocator);
-  }
-  void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySwapchainKHR( device, swapchain, pAllocator);
-  }
-  void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator);
-  }
-  VkResult vkDeviceWaitIdle( VkDevice device  ) const
-  {
-    return ::vkDeviceWaitIdle( device);
-  }
-  VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo  ) const
-  {
-    return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo);
-  }
-  VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkEndCommandBuffer( commandBuffer);
-  }
-  VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties  ) const
-  {
-    return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties  ) const
-  {
-    return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties  ) const
-  {
-    return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties  ) const
-  {
-    return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateInstanceVersion( uint32_t* pApiVersion  ) const
-  {
-    return ::vkEnumerateInstanceVersion( pApiVersion);
-  }
-  VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties  ) const
-  {
-    return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-  }
-  VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties  ) const
-  {
-    return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-  }
-  VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices  ) const
-  {
-    return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices);
-  }
-  VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges  ) const
-  {
-    return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges);
-  }
-  void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers  ) const
-  {
-    return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers);
-  }
-  VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets  ) const
-  {
-    return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets);
-  }
-  void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkFreeMemory( device, memory, pAllocator);
-  }
-  VkResult vkGetAccelerationStructureHandleNVX( VkDevice device, VkAccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData  ) const
-  {
-    return ::vkGetAccelerationStructureHandleNVX( device, accelerationStructure, dataSize, pData);
-  }
-  void vkGetAccelerationStructureMemoryRequirementsNVX( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements  ) const
-  {
-    return ::vkGetAccelerationStructureMemoryRequirementsNVX( device, pInfo, pMemoryRequirements);
-  }
-  void vkGetAccelerationStructureScratchMemoryRequirementsNVX( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements  ) const
-  {
-    return ::vkGetAccelerationStructureScratchMemoryRequirementsNVX( device, pInfo, pMemoryRequirements);
-  }
-#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
-  VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties  ) const
-  {
-    return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties);
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
-  void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements  ) const
-  {
-    return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements);
-  }
-  void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements);
-  }
-  void vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements);
-  }
-  VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation  ) const
-  {
-    return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
-  }
-  void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport  ) const
-  {
-    return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport);
-  }
-  void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport  ) const
-  {
-    return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport);
-  }
-  void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures  ) const
-  {
-    return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-  }
-  void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures  ) const
-  {
-    return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-  }
-  VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities  ) const
-  {
-    return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities);
-  }
-  VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes  ) const
-  {
-    return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes);
-  }
-  void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes  ) const
-  {
-    return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes);
-  }
-  PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char* pName  ) const
-  {
-    return ::vkGetDeviceProcAddr( device, pName);
-  }
-  void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue  ) const
-  {
-    return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue);
-  }
-  void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue  ) const
-  {
-    return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue);
-  }
-  VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties  ) const
-  {
-    return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties);
-  }
-  VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties  ) const
-  {
-    return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties);
-  }
-  VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities  ) const
-  {
-    return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities);
-  }
-  VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities  ) const
-  {
-    return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities);
-  }
-  VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays  ) const
-  {
-    return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays);
-  }
-  VkResult vkGetEventStatus( VkDevice device, VkEvent event  ) const
-  {
-    return ::vkGetEventStatus( device, event);
-  }
-  VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd  ) const
-  {
-    return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd);
-  }
-  VkResult vkGetFenceStatus( VkDevice device, VkFence fence  ) const
-  {
-    return ::vkGetFenceStatus( device, fence);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle  ) const
-  {
-    return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties  ) const
-  {
-    return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties);
-  }
-  void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements  ) const
-  {
-    return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements);
-  }
-  void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements);
-  }
-  void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements);
-  }
-  void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements  ) const
-  {
-    return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-  }
-  void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements  ) const
-  {
-    return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-  }
-  void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements  ) const
-  {
-    return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-  }
-  void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout  ) const
-  {
-    return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout);
-  }
-  PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName  ) const
-  {
-    return ::vkGetInstanceProcAddr( instance, pName);
-  }
-#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
-  VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer  ) const
-  {
-    return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer);
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
-  VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd  ) const
-  {
-    return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd);
-  }
-  VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties  ) const
-  {
-    return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties);
-  }
-  VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties  ) const
-  {
-    return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle  ) const
-  {
-    return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_NV
-  VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle  ) const
-  {
-    return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_NV*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties  ) const
-  {
-    return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings  ) const
-  {
-    return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings);
-  }
-  VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains  ) const
-  {
-    return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains);
-  }
-  VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-  }
-  void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-  }
-  void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-  }
-  void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-  }
-  VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
-  }
-  void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-  }
-  void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-  }
-  void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures  ) const
-  {
-    return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures);
-  }
-  void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures  ) const
-  {
-    return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures);
-  }
-  void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures  ) const
-  {
-    return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures);
-  }
-  void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties);
-  }
-  void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties);
-  }
-  void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties);
-  }
-  void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits  ) const
-  {
-    return ::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( physicalDevice, pFeatures, pLimits);
-  }
-  VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-  }
-  VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties);
-  }
-  VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties);
-  }
-  void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties);
-  }
-  void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties);
-  }
-  void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties);
-  }
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection  ) const
-  {
-    return ::vkGetPhysicalDeviceMirPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection);
-  }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-  void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties);
-  }
-  VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects  ) const
-  {
-    return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects);
-  }
-  void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties);
-  }
-  void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties);
-  }
-  void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties);
-  }
-  void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-  void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-  void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-  void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-  }
-  void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-  }
-  void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-  }
-  VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported);
-  }
+
+    void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const
+    {
+      return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
+    }
+
+    void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
+    }
+
+    void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
+    }
+
+    void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyInstance( instance, pAllocator );
+    }
+
+    void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const
+    {
+      return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const
+    {
+      return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices ) const
+    {
+      return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
+    }
+
+    PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName ) const
+    {
+      return ::vkGetInstanceProcAddr( instance, pName );
+    }
+
+    void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData ) const
+    {
+      return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
+    }
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const
+    {
+      return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
+    }
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice ) const
+    {
+      return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
+    }
+
+    VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode ) const
+    {
+      return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
+    }
+
+    VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const
+    {
+      return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const
+    {
+      return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties ) const
+    {
+      return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties ) const
+    {
+      return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities ) const
+    {
+      return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
+    }
+
+    VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities ) const
+    {
+      return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
+    }
+
+    VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays ) const
+    {
+      return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
+    }
+
+    VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains ) const
+    {
+      return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
+    }
+
+    VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+    }
+
+    void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures ) const
+    {
+      return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const
+    {
+      return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const
+    {
+      return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits ) const
+    {
+      return ::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( physicalDevice, pFeatures, pLimits );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
+    }
+
+    VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects ) const
+    {
+      return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
+    }
+
+    void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties ) const
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const
+    {
+      return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
+    }
+
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display  ) const
-  {
-    return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display);
-  }
+    VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display ) const
+    {
+      return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
+    }
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex  ) const
-  {
-    return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex);
-  }
+    VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const
+    {
+      return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
+    }
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VK_USE_PLATFORM_XCB_KHR
-  VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id  ) const
-  {
-    return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id);
-  }
+    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const
+    {
+      return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
+    }
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
+
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-  VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID  ) const
-  {
-    return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID);
-  }
+    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const
+    {
+      return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
+    }
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
-  VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData  ) const
-  {
-    return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData);
-  }
-  VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags  ) const
-  {
-    return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-  }
-  void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData  ) const
-  {
-    return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData);
-  }
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
-  VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay  ) const
-  {
-    return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay);
-  }
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
-  VkResult vkGetRaytracingShaderHandlesNVX( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData  ) const
-  {
-    return ::vkGetRaytracingShaderHandlesNVX( device, pipeline, firstGroup, groupCount, dataSize, pData);
-  }
-  VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties  ) const
-  {
-    return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties);
-  }
-  void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity  ) const
-  {
-    return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity);
-  }
-  VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd  ) const
-  {
-    return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle  ) const
-  {
-    return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo  ) const
-  {
-    return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
-  }
-  VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue  ) const
-  {
-    return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue);
-  }
-  VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages  ) const
-  {
-    return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages);
-  }
-  VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain  ) const
-  {
-    return ::vkGetSwapchainStatusKHR( device, swapchain);
-  }
-  VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData  ) const
-  {
-    return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData);
-  }
-  VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo  ) const
-  {
-    return ::vkImportFenceFdKHR( device, pImportFenceFdInfo);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo  ) const
-  {
-    return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo  ) const
-  {
-    return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo  ) const
-  {
-    return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges  ) const
-  {
-    return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges);
-  }
-  VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData  ) const
-  {
-    return ::vkMapMemory( device, memory, offset, size, flags, ppData);
-  }
-  VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches  ) const
-  {
-    return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches);
-  }
-  VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches  ) const
-  {
-    return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches);
-  }
-  void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo);
-  }
-  VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence  ) const
-  {
-    return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence);
-  }
-  void vkQueueEndDebugUtilsLabelEXT( VkQueue queue  ) const
-  {
-    return ::vkQueueEndDebugUtilsLabelEXT( queue);
-  }
-  void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo);
-  }
-  VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo  ) const
-  {
-    return ::vkQueuePresentKHR( queue, pPresentInfo);
-  }
-  VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence  ) const
-  {
-    return ::vkQueueSubmit( queue, submitCount, pSubmits, fence);
-  }
-  VkResult vkQueueWaitIdle( VkQueue queue  ) const
-  {
-    return ::vkQueueWaitIdle( queue);
-  }
-  VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence  ) const
-  {
-    return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence);
-  }
-  VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence  ) const
-  {
-    return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence);
-  }
-  VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices  ) const
-  {
-    return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
-  }
-  VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display  ) const
-  {
-    return ::vkReleaseDisplayEXT( physicalDevice, display);
-  }
-  VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags  ) const
-  {
-    return ::vkResetCommandBuffer( commandBuffer, flags);
-  }
-  VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags  ) const
-  {
-    return ::vkResetCommandPool( device, commandPool, flags);
-  }
-  VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags  ) const
-  {
-    return ::vkResetDescriptorPool( device, descriptorPool, flags);
-  }
-  VkResult vkResetEvent( VkDevice device, VkEvent event  ) const
-  {
-    return ::vkResetEvent( device, event);
-  }
-  VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences  ) const
-  {
-    return ::vkResetFences( device, fenceCount, pFences);
-  }
-  VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo  ) const
-  {
-    return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo);
-  }
-  VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo  ) const
-  {
-    return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo);
-  }
-  VkResult vkSetEvent( VkDevice device, VkEvent event  ) const
-  {
-    return ::vkSetEvent( device, event);
-  }
-  void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata  ) const
-  {
-    return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata);
-  }
-  void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData  ) const
-  {
-    return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData);
-  }
-  void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags  ) const
-  {
-    return ::vkTrimCommandPool( device, commandPool, flags);
-  }
-  void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags  ) const
-  {
-    return ::vkTrimCommandPoolKHR( device, commandPool, flags);
-  }
-  void vkUnmapMemory( VkDevice device, VkDeviceMemory memory  ) const
-  {
-    return ::vkUnmapMemory( device, memory);
-  }
-  VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices  ) const
-  {
-    return ::vkUnregisterObjectsNVX( device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
-  }
-  void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData  ) const
-  {
-    return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData);
-  }
-  void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData  ) const
-  {
-    return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData);
-  }
-  void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies  ) const
-  {
-    return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-  }
-  VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout  ) const
-  {
-    return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout);
-  }
-};
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ) const
+    {
+      return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
+    }
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const
+    {
+      return ::vkReleaseDisplayEXT( physicalDevice, display );
+    }
+
+    void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData ) const
+    {
+      return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
+    }
+
+    void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
+    }
+
+    VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence ) const
+    {
+      return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
+    }
+
+    void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const
+    {
+      return ::vkQueueEndDebugUtilsLabelEXT( queue );
+    }
+
+    void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
+    }
+
+    VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo ) const
+    {
+      return ::vkQueuePresentKHR( queue, pPresentInfo );
+    }
+
+    VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence ) const
+    {
+      return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
+    }
+
+    VkResult vkQueueWaitIdle( VkQueue queue ) const
+    {
+      return ::vkQueueWaitIdle( queue );
+    }
+  };
 
   struct AllocationCallbacks;
 
@@ -2629,5443 +2478,44 @@
       Dispatch const* m_dispatch;
   };
 
+  using Bool32 = uint32_t;
+  using DeviceAddress = uint64_t;
+  using DeviceSize = uint64_t;
   using SampleMask = uint32_t;
 
-  using Bool32 = uint32_t;
-
-  using DeviceSize = uint64_t;
-
-  enum class FramebufferCreateFlagBits
+  enum class AccelerationStructureMemoryRequirementsTypeNV
   {
+    eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
+    eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV,
+    eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV
   };
 
-  using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
-
-  enum class QueryPoolCreateFlagBits
+  VULKAN_HPP_INLINE std::string to_string( AccelerationStructureMemoryRequirementsTypeNV value )
   {
-  };
-
-  using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>;
-
-  enum class RenderPassCreateFlagBits
-  {
-  };
-
-  using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>;
-
-  enum class SamplerCreateFlagBits
-  {
-  };
-
-  using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;
-
-  enum class PipelineLayoutCreateFlagBits
-  {
-  };
-
-  using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>;
-
-  enum class PipelineCacheCreateFlagBits
-  {
-  };
-
-  using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>;
-
-  enum class PipelineDepthStencilStateCreateFlagBits
-  {
-  };
-
-  using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>;
-
-  enum class PipelineDynamicStateCreateFlagBits
-  {
-  };
-
-  using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>;
-
-  enum class PipelineColorBlendStateCreateFlagBits
-  {
-  };
-
-  using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>;
-
-  enum class PipelineMultisampleStateCreateFlagBits
-  {
-  };
-
-  using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>;
-
-  enum class PipelineRasterizationStateCreateFlagBits
-  {
-  };
-
-  using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>;
-
-  enum class PipelineViewportStateCreateFlagBits
-  {
-  };
-
-  using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>;
-
-  enum class PipelineTessellationStateCreateFlagBits
-  {
-  };
-
-  using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>;
-
-  enum class PipelineInputAssemblyStateCreateFlagBits
-  {
-  };
-
-  using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>;
-
-  enum class PipelineVertexInputStateCreateFlagBits
-  {
-  };
-
-  using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>;
-
-  enum class PipelineShaderStageCreateFlagBits
-  {
-  };
-
-  using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
-
-  enum class BufferViewCreateFlagBits
-  {
-  };
-
-  using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;
-
-  enum class InstanceCreateFlagBits
-  {
-  };
-
-  using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>;
-
-  enum class DeviceCreateFlagBits
-  {
-  };
-
-  using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>;
-
-  enum class ImageViewCreateFlagBits
-  {
-  };
-
-  using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;
-
-  enum class SemaphoreCreateFlagBits
-  {
-  };
-
-  using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>;
-
-  enum class ShaderModuleCreateFlagBits
-  {
-  };
-
-  using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>;
-
-  enum class EventCreateFlagBits
-  {
-  };
-
-  using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>;
-
-  enum class MemoryMapFlagBits
-  {
-  };
-
-  using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>;
-
-  enum class DescriptorPoolResetFlagBits
-  {
-  };
-
-  using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>;
-
-  enum class DescriptorUpdateTemplateCreateFlagBits
-  {
-  };
-
-  using DescriptorUpdateTemplateCreateFlags = Flags<DescriptorUpdateTemplateCreateFlagBits, VkDescriptorUpdateTemplateCreateFlags>;
-
-  using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
-
-  enum class DisplayModeCreateFlagBitsKHR
-  {
-  };
-
-  using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>;
-
-  enum class DisplaySurfaceCreateFlagBitsKHR
-  {
-  };
-
-  using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  enum class AndroidSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  enum class MirSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  using MirSurfaceCreateFlagsKHR = Flags<MirSurfaceCreateFlagBitsKHR, VkMirSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  enum class ViSurfaceCreateFlagBitsNN
-  {
-  };
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN, VkViSurfaceCreateFlagsNN>;
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  enum class WaylandSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  enum class Win32SurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  enum class XlibSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  enum class XcbSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  enum class IOSSurfaceCreateFlagBitsMVK
-  {
-  };
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>;
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  enum class MacOSSurfaceCreateFlagBitsMVK
-  {
-  };
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
-  enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA
-  {
-  };
-#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
-  using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA, VkImagePipeSurfaceCreateFlagsFUCHSIA>;
-#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
-
-  enum class CommandPoolTrimFlagBits
-  {
-  };
-
-  using CommandPoolTrimFlags = Flags<CommandPoolTrimFlagBits, VkCommandPoolTrimFlags>;
-
-  using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
-
-  enum class PipelineViewportSwizzleStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV>;
-
-  enum class PipelineDiscardRectangleStateCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT>;
-
-  enum class PipelineCoverageToColorStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineCoverageToColorStateCreateFlagsNV = Flags<PipelineCoverageToColorStateCreateFlagBitsNV, VkPipelineCoverageToColorStateCreateFlagsNV>;
-
-  enum class PipelineCoverageModulationStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineCoverageModulationStateCreateFlagsNV = Flags<PipelineCoverageModulationStateCreateFlagBitsNV, VkPipelineCoverageModulationStateCreateFlagsNV>;
-
-  enum class ValidationCacheCreateFlagBitsEXT
-  {
-  };
-
-  using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT, VkValidationCacheCreateFlagsEXT>;
-
-  enum class DebugUtilsMessengerCreateFlagBitsEXT
-  {
-  };
-
-  using DebugUtilsMessengerCreateFlagsEXT = Flags<DebugUtilsMessengerCreateFlagBitsEXT, VkDebugUtilsMessengerCreateFlagsEXT>;
-
-  enum class DebugUtilsMessengerCallbackDataFlagBitsEXT
-  {
-  };
-
-  using DebugUtilsMessengerCallbackDataFlagsEXT = Flags<DebugUtilsMessengerCallbackDataFlagBitsEXT, VkDebugUtilsMessengerCallbackDataFlagsEXT>;
-
-  enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT>;
-
-  enum class PipelineRasterizationStateStreamCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineRasterizationStateStreamCreateFlagsEXT = Flags<PipelineRasterizationStateStreamCreateFlagBitsEXT, VkPipelineRasterizationStateStreamCreateFlagsEXT>;
-
-  class DeviceMemory
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DeviceMemory()
-      : m_deviceMemory(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t )
-      : m_deviceMemory(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory )
-      : m_deviceMemory( deviceMemory )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DeviceMemory & operator=(VkDeviceMemory deviceMemory)
-    {
-      m_deviceMemory = deviceMemory;
-      return *this; 
-    }
-#endif
-
-    DeviceMemory & operator=( std::nullptr_t )
-    {
-      m_deviceMemory = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory == rhs.m_deviceMemory;
-    }
-
-    bool operator!=(DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory != rhs.m_deviceMemory;
-    }
-
-    bool operator<(DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory < rhs.m_deviceMemory;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const
-    {
-      return m_deviceMemory;
-    }
-
-    explicit operator bool() const
-    {
-      return m_deviceMemory != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
+    switch ( value )
     {
-      return m_deviceMemory == VK_NULL_HANDLE;
+      case AccelerationStructureMemoryRequirementsTypeNV::eObject : return "Object";
+      case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch : return "BuildScratch";
+      case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch : return "UpdateScratch";
+      default: return "invalid";
     }
+  }
 
-  private:
-    VkDeviceMemory m_deviceMemory;
-  };
-
-  static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
-
-  class CommandPool
+  enum class AccelerationStructureTypeNV
   {
-  public:
-    VULKAN_HPP_CONSTEXPR CommandPool()
-      : m_commandPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t )
-      : m_commandPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool )
-      : m_commandPool( commandPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    CommandPool & operator=(VkCommandPool commandPool)
-    {
-      m_commandPool = commandPool;
-      return *this; 
-    }
-#endif
-
-    CommandPool & operator=( std::nullptr_t )
-    {
-      m_commandPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( CommandPool const & rhs ) const
-    {
-      return m_commandPool == rhs.m_commandPool;
-    }
-
-    bool operator!=(CommandPool const & rhs ) const
-    {
-      return m_commandPool != rhs.m_commandPool;
-    }
-
-    bool operator<(CommandPool const & rhs ) const
-    {
-      return m_commandPool < rhs.m_commandPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const
-    {
-      return m_commandPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_commandPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_commandPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkCommandPool m_commandPool;
+    eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
+    eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV
   };
 
-  static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
-
-  class Buffer
+  VULKAN_HPP_INLINE std::string to_string( AccelerationStructureTypeNV value )
   {
-  public:
-    VULKAN_HPP_CONSTEXPR Buffer()
-      : m_buffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t )
-      : m_buffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer )
-      : m_buffer( buffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Buffer & operator=(VkBuffer buffer)
+    switch ( value )
     {
-      m_buffer = buffer;
-      return *this; 
+      case AccelerationStructureTypeNV::eTopLevel : return "TopLevel";
+      case AccelerationStructureTypeNV::eBottomLevel : return "BottomLevel";
+      default: return "invalid";
     }
-#endif
-
-    Buffer & operator=( std::nullptr_t )
-    {
-      m_buffer = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Buffer const & rhs ) const
-    {
-      return m_buffer == rhs.m_buffer;
-    }
-
-    bool operator!=(Buffer const & rhs ) const
-    {
-      return m_buffer != rhs.m_buffer;
-    }
-
-    bool operator<(Buffer const & rhs ) const
-    {
-      return m_buffer < rhs.m_buffer;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const
-    {
-      return m_buffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_buffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_buffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkBuffer m_buffer;
-  };
-
-  static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
-
-  class BufferView
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR BufferView()
-      : m_bufferView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t )
-      : m_bufferView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView )
-      : m_bufferView( bufferView )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    BufferView & operator=(VkBufferView bufferView)
-    {
-      m_bufferView = bufferView;
-      return *this; 
-    }
-#endif
-
-    BufferView & operator=( std::nullptr_t )
-    {
-      m_bufferView = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( BufferView const & rhs ) const
-    {
-      return m_bufferView == rhs.m_bufferView;
-    }
-
-    bool operator!=(BufferView const & rhs ) const
-    {
-      return m_bufferView != rhs.m_bufferView;
-    }
-
-    bool operator<(BufferView const & rhs ) const
-    {
-      return m_bufferView < rhs.m_bufferView;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const
-    {
-      return m_bufferView;
-    }
-
-    explicit operator bool() const
-    {
-      return m_bufferView != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_bufferView == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkBufferView m_bufferView;
-  };
-
-  static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
-
-  class Image
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Image()
-      : m_image(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Image( std::nullptr_t )
-      : m_image(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image )
-      : m_image( image )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Image & operator=(VkImage image)
-    {
-      m_image = image;
-      return *this; 
-    }
-#endif
-
-    Image & operator=( std::nullptr_t )
-    {
-      m_image = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Image const & rhs ) const
-    {
-      return m_image == rhs.m_image;
-    }
-
-    bool operator!=(Image const & rhs ) const
-    {
-      return m_image != rhs.m_image;
-    }
-
-    bool operator<(Image const & rhs ) const
-    {
-      return m_image < rhs.m_image;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const
-    {
-      return m_image;
-    }
-
-    explicit operator bool() const
-    {
-      return m_image != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_image == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkImage m_image;
-  };
-
-  static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
-
-  class ImageView
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ImageView()
-      : m_imageView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t )
-      : m_imageView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView )
-      : m_imageView( imageView )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ImageView & operator=(VkImageView imageView)
-    {
-      m_imageView = imageView;
-      return *this; 
-    }
-#endif
-
-    ImageView & operator=( std::nullptr_t )
-    {
-      m_imageView = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ImageView const & rhs ) const
-    {
-      return m_imageView == rhs.m_imageView;
-    }
-
-    bool operator!=(ImageView const & rhs ) const
-    {
-      return m_imageView != rhs.m_imageView;
-    }
-
-    bool operator<(ImageView const & rhs ) const
-    {
-      return m_imageView < rhs.m_imageView;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const
-    {
-      return m_imageView;
-    }
-
-    explicit operator bool() const
-    {
-      return m_imageView != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_imageView == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkImageView m_imageView;
-  };
-
-  static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
-
-  class ShaderModule
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ShaderModule()
-      : m_shaderModule(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t )
-      : m_shaderModule(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule )
-      : m_shaderModule( shaderModule )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ShaderModule & operator=(VkShaderModule shaderModule)
-    {
-      m_shaderModule = shaderModule;
-      return *this; 
-    }
-#endif
-
-    ShaderModule & operator=( std::nullptr_t )
-    {
-      m_shaderModule = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ShaderModule const & rhs ) const
-    {
-      return m_shaderModule == rhs.m_shaderModule;
-    }
-
-    bool operator!=(ShaderModule const & rhs ) const
-    {
-      return m_shaderModule != rhs.m_shaderModule;
-    }
-
-    bool operator<(ShaderModule const & rhs ) const
-    {
-      return m_shaderModule < rhs.m_shaderModule;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const
-    {
-      return m_shaderModule;
-    }
-
-    explicit operator bool() const
-    {
-      return m_shaderModule != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_shaderModule == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkShaderModule m_shaderModule;
-  };
-
-  static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
-
-  class Pipeline
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Pipeline()
-      : m_pipeline(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t )
-      : m_pipeline(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline )
-      : m_pipeline( pipeline )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Pipeline & operator=(VkPipeline pipeline)
-    {
-      m_pipeline = pipeline;
-      return *this; 
-    }
-#endif
-
-    Pipeline & operator=( std::nullptr_t )
-    {
-      m_pipeline = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Pipeline const & rhs ) const
-    {
-      return m_pipeline == rhs.m_pipeline;
-    }
-
-    bool operator!=(Pipeline const & rhs ) const
-    {
-      return m_pipeline != rhs.m_pipeline;
-    }
-
-    bool operator<(Pipeline const & rhs ) const
-    {
-      return m_pipeline < rhs.m_pipeline;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const
-    {
-      return m_pipeline;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipeline != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipeline == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipeline m_pipeline;
-  };
-
-  static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
-
-  class PipelineLayout
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR PipelineLayout()
-      : m_pipelineLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t )
-      : m_pipelineLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout )
-      : m_pipelineLayout( pipelineLayout )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PipelineLayout & operator=(VkPipelineLayout pipelineLayout)
-    {
-      m_pipelineLayout = pipelineLayout;
-      return *this; 
-    }
-#endif
-
-    PipelineLayout & operator=( std::nullptr_t )
-    {
-      m_pipelineLayout = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout == rhs.m_pipelineLayout;
-    }
-
-    bool operator!=(PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout != rhs.m_pipelineLayout;
-    }
-
-    bool operator<(PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout < rhs.m_pipelineLayout;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const
-    {
-      return m_pipelineLayout;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipelineLayout != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipelineLayout == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipelineLayout m_pipelineLayout;
-  };
-
-  static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
-
-  class Sampler
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Sampler()
-      : m_sampler(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t )
-      : m_sampler(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler )
-      : m_sampler( sampler )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Sampler & operator=(VkSampler sampler)
-    {
-      m_sampler = sampler;
-      return *this; 
-    }
-#endif
-
-    Sampler & operator=( std::nullptr_t )
-    {
-      m_sampler = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Sampler const & rhs ) const
-    {
-      return m_sampler == rhs.m_sampler;
-    }
-
-    bool operator!=(Sampler const & rhs ) const
-    {
-      return m_sampler != rhs.m_sampler;
-    }
-
-    bool operator<(Sampler const & rhs ) const
-    {
-      return m_sampler < rhs.m_sampler;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const
-    {
-      return m_sampler;
-    }
-
-    explicit operator bool() const
-    {
-      return m_sampler != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_sampler == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSampler m_sampler;
-  };
-
-  static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
-
-  class DescriptorSet
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorSet()
-      : m_descriptorSet(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t )
-      : m_descriptorSet(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet )
-      : m_descriptorSet( descriptorSet )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorSet & operator=(VkDescriptorSet descriptorSet)
-    {
-      m_descriptorSet = descriptorSet;
-      return *this; 
-    }
-#endif
-
-    DescriptorSet & operator=( std::nullptr_t )
-    {
-      m_descriptorSet = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet == rhs.m_descriptorSet;
-    }
-
-    bool operator!=(DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet != rhs.m_descriptorSet;
-    }
-
-    bool operator<(DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet < rhs.m_descriptorSet;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const
-    {
-      return m_descriptorSet;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorSet != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorSet == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorSet m_descriptorSet;
-  };
-
-  static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
-
-  class DescriptorSetLayout
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
-      : m_descriptorSetLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t )
-      : m_descriptorSetLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout )
-      : m_descriptorSetLayout( descriptorSetLayout )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout)
-    {
-      m_descriptorSetLayout = descriptorSetLayout;
-      return *this; 
-    }
-#endif
-
-    DescriptorSetLayout & operator=( std::nullptr_t )
-    {
-      m_descriptorSetLayout = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
-    }
-
-    bool operator!=(DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
-    }
-
-    bool operator<(DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const
-    {
-      return m_descriptorSetLayout;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorSetLayout != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorSetLayout == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorSetLayout m_descriptorSetLayout;
-  };
-
-  static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
-
-  class DescriptorPool
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorPool()
-      : m_descriptorPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t )
-      : m_descriptorPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool )
-      : m_descriptorPool( descriptorPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorPool & operator=(VkDescriptorPool descriptorPool)
-    {
-      m_descriptorPool = descriptorPool;
-      return *this; 
-    }
-#endif
-
-    DescriptorPool & operator=( std::nullptr_t )
-    {
-      m_descriptorPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool == rhs.m_descriptorPool;
-    }
-
-    bool operator!=(DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool != rhs.m_descriptorPool;
-    }
-
-    bool operator<(DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool < rhs.m_descriptorPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const
-    {
-      return m_descriptorPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorPool m_descriptorPool;
-  };
-
-  static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
-
-  class Fence
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Fence()
-      : m_fence(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t )
-      : m_fence(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence )
-      : m_fence( fence )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Fence & operator=(VkFence fence)
-    {
-      m_fence = fence;
-      return *this; 
-    }
-#endif
-
-    Fence & operator=( std::nullptr_t )
-    {
-      m_fence = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Fence const & rhs ) const
-    {
-      return m_fence == rhs.m_fence;
-    }
-
-    bool operator!=(Fence const & rhs ) const
-    {
-      return m_fence != rhs.m_fence;
-    }
-
-    bool operator<(Fence const & rhs ) const
-    {
-      return m_fence < rhs.m_fence;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const
-    {
-      return m_fence;
-    }
-
-    explicit operator bool() const
-    {
-      return m_fence != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_fence == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkFence m_fence;
-  };
-
-  static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
-
-  class Semaphore
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Semaphore()
-      : m_semaphore(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t )
-      : m_semaphore(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore )
-      : m_semaphore( semaphore )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Semaphore & operator=(VkSemaphore semaphore)
-    {
-      m_semaphore = semaphore;
-      return *this; 
-    }
-#endif
-
-    Semaphore & operator=( std::nullptr_t )
-    {
-      m_semaphore = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Semaphore const & rhs ) const
-    {
-      return m_semaphore == rhs.m_semaphore;
-    }
-
-    bool operator!=(Semaphore const & rhs ) const
-    {
-      return m_semaphore != rhs.m_semaphore;
-    }
-
-    bool operator<(Semaphore const & rhs ) const
-    {
-      return m_semaphore < rhs.m_semaphore;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const
-    {
-      return m_semaphore;
-    }
-
-    explicit operator bool() const
-    {
-      return m_semaphore != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_semaphore == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSemaphore m_semaphore;
-  };
-
-  static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
-
-  class Event
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Event()
-      : m_event(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Event( std::nullptr_t )
-      : m_event(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event )
-      : m_event( event )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Event & operator=(VkEvent event)
-    {
-      m_event = event;
-      return *this; 
-    }
-#endif
-
-    Event & operator=( std::nullptr_t )
-    {
-      m_event = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Event const & rhs ) const
-    {
-      return m_event == rhs.m_event;
-    }
-
-    bool operator!=(Event const & rhs ) const
-    {
-      return m_event != rhs.m_event;
-    }
-
-    bool operator<(Event const & rhs ) const
-    {
-      return m_event < rhs.m_event;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const
-    {
-      return m_event;
-    }
-
-    explicit operator bool() const
-    {
-      return m_event != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_event == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkEvent m_event;
-  };
-
-  static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
-
-  class QueryPool
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR QueryPool()
-      : m_queryPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t )
-      : m_queryPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool )
-      : m_queryPool( queryPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    QueryPool & operator=(VkQueryPool queryPool)
-    {
-      m_queryPool = queryPool;
-      return *this; 
-    }
-#endif
-
-    QueryPool & operator=( std::nullptr_t )
-    {
-      m_queryPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( QueryPool const & rhs ) const
-    {
-      return m_queryPool == rhs.m_queryPool;
-    }
-
-    bool operator!=(QueryPool const & rhs ) const
-    {
-      return m_queryPool != rhs.m_queryPool;
-    }
-
-    bool operator<(QueryPool const & rhs ) const
-    {
-      return m_queryPool < rhs.m_queryPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const
-    {
-      return m_queryPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_queryPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_queryPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkQueryPool m_queryPool;
-  };
-
-  static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
-
-  class Framebuffer
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Framebuffer()
-      : m_framebuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t )
-      : m_framebuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer )
-      : m_framebuffer( framebuffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Framebuffer & operator=(VkFramebuffer framebuffer)
-    {
-      m_framebuffer = framebuffer;
-      return *this; 
-    }
-#endif
-
-    Framebuffer & operator=( std::nullptr_t )
-    {
-      m_framebuffer = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Framebuffer const & rhs ) const
-    {
-      return m_framebuffer == rhs.m_framebuffer;
-    }
-
-    bool operator!=(Framebuffer const & rhs ) const
-    {
-      return m_framebuffer != rhs.m_framebuffer;
-    }
-
-    bool operator<(Framebuffer const & rhs ) const
-    {
-      return m_framebuffer < rhs.m_framebuffer;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const
-    {
-      return m_framebuffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_framebuffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_framebuffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkFramebuffer m_framebuffer;
-  };
-
-  static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
-
-  class RenderPass
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR RenderPass()
-      : m_renderPass(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t )
-      : m_renderPass(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass )
-      : m_renderPass( renderPass )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    RenderPass & operator=(VkRenderPass renderPass)
-    {
-      m_renderPass = renderPass;
-      return *this; 
-    }
-#endif
-
-    RenderPass & operator=( std::nullptr_t )
-    {
-      m_renderPass = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( RenderPass const & rhs ) const
-    {
-      return m_renderPass == rhs.m_renderPass;
-    }
-
-    bool operator!=(RenderPass const & rhs ) const
-    {
-      return m_renderPass != rhs.m_renderPass;
-    }
-
-    bool operator<(RenderPass const & rhs ) const
-    {
-      return m_renderPass < rhs.m_renderPass;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const
-    {
-      return m_renderPass;
-    }
-
-    explicit operator bool() const
-    {
-      return m_renderPass != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_renderPass == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkRenderPass m_renderPass;
-  };
-
-  static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
-
-  class PipelineCache
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR PipelineCache()
-      : m_pipelineCache(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t )
-      : m_pipelineCache(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache )
-      : m_pipelineCache( pipelineCache )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PipelineCache & operator=(VkPipelineCache pipelineCache)
-    {
-      m_pipelineCache = pipelineCache;
-      return *this; 
-    }
-#endif
-
-    PipelineCache & operator=( std::nullptr_t )
-    {
-      m_pipelineCache = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache == rhs.m_pipelineCache;
-    }
-
-    bool operator!=(PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache != rhs.m_pipelineCache;
-    }
-
-    bool operator<(PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache < rhs.m_pipelineCache;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const
-    {
-      return m_pipelineCache;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipelineCache != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipelineCache == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipelineCache m_pipelineCache;
-  };
-
-  static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
-
-  class ObjectTableNVX
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ObjectTableNVX()
-      : m_objectTableNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ObjectTableNVX( std::nullptr_t )
-      : m_objectTableNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX )
-      : m_objectTableNVX( objectTableNVX )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX)
-    {
-      m_objectTableNVX = objectTableNVX;
-      return *this; 
-    }
-#endif
-
-    ObjectTableNVX & operator=( std::nullptr_t )
-    {
-      m_objectTableNVX = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX == rhs.m_objectTableNVX;
-    }
-
-    bool operator!=(ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX != rhs.m_objectTableNVX;
-    }
-
-    bool operator<(ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX < rhs.m_objectTableNVX;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const
-    {
-      return m_objectTableNVX;
-    }
-
-    explicit operator bool() const
-    {
-      return m_objectTableNVX != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_objectTableNVX == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkObjectTableNVX m_objectTableNVX;
-  };
-
-  static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
-
-  class IndirectCommandsLayoutNVX
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
-      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX( std::nullptr_t )
-      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
-      : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
-    {
-      m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX;
-      return *this; 
-    }
-#endif
-
-    IndirectCommandsLayoutNVX & operator=( std::nullptr_t )
-    {
-      m_indirectCommandsLayoutNVX = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX;
-    }
-
-    bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX;
-    }
-
-    bool operator<(IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const
-    {
-      return m_indirectCommandsLayoutNVX;
-    }
-
-    explicit operator bool() const
-    {
-      return m_indirectCommandsLayoutNVX != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_indirectCommandsLayoutNVX == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX;
-  };
-
-  static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
-
-  class DescriptorUpdateTemplate
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
-      : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t )
-      : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate )
-      : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate)
-    {
-      m_descriptorUpdateTemplate = descriptorUpdateTemplate;
-      return *this; 
-    }
-#endif
-
-    DescriptorUpdateTemplate & operator=( std::nullptr_t )
-    {
-      m_descriptorUpdateTemplate = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorUpdateTemplate const & rhs ) const
-    {
-      return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
-    }
-
-    bool operator!=(DescriptorUpdateTemplate const & rhs ) const
-    {
-      return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
-    }
-
-    bool operator<(DescriptorUpdateTemplate const & rhs ) const
-    {
-      return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const
-    {
-      return m_descriptorUpdateTemplate;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
-  };
-
-  static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
-
-  using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
-
-  class SamplerYcbcrConversion
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
-      : m_samplerYcbcrConversion(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t )
-      : m_samplerYcbcrConversion(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion )
-      : m_samplerYcbcrConversion( samplerYcbcrConversion )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion)
-    {
-      m_samplerYcbcrConversion = samplerYcbcrConversion;
-      return *this; 
-    }
-#endif
-
-    SamplerYcbcrConversion & operator=( std::nullptr_t )
-    {
-      m_samplerYcbcrConversion = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SamplerYcbcrConversion const & rhs ) const
-    {
-      return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
-    }
-
-    bool operator!=(SamplerYcbcrConversion const & rhs ) const
-    {
-      return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
-    }
-
-    bool operator<(SamplerYcbcrConversion const & rhs ) const
-    {
-      return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const
-    {
-      return m_samplerYcbcrConversion;
-    }
-
-    explicit operator bool() const
-    {
-      return m_samplerYcbcrConversion != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_samplerYcbcrConversion == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSamplerYcbcrConversion m_samplerYcbcrConversion;
-  };
-
-  static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
-
-  using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
-
-  class ValidationCacheEXT
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
-      : m_validationCacheEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t )
-      : m_validationCacheEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT )
-      : m_validationCacheEXT( validationCacheEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT)
-    {
-      m_validationCacheEXT = validationCacheEXT;
-      return *this; 
-    }
-#endif
-
-    ValidationCacheEXT & operator=( std::nullptr_t )
-    {
-      m_validationCacheEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT == rhs.m_validationCacheEXT;
-    }
-
-    bool operator!=(ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT != rhs.m_validationCacheEXT;
-    }
-
-    bool operator<(ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT < rhs.m_validationCacheEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const
-    {
-      return m_validationCacheEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_validationCacheEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_validationCacheEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkValidationCacheEXT m_validationCacheEXT;
-  };
-
-  static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
-
-  class AccelerationStructureNVX
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR AccelerationStructureNVX()
-      : m_accelerationStructureNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR AccelerationStructureNVX( std::nullptr_t )
-      : m_accelerationStructureNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNVX( VkAccelerationStructureNVX accelerationStructureNVX )
-      : m_accelerationStructureNVX( accelerationStructureNVX )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    AccelerationStructureNVX & operator=(VkAccelerationStructureNVX accelerationStructureNVX)
-    {
-      m_accelerationStructureNVX = accelerationStructureNVX;
-      return *this; 
-    }
-#endif
-
-    AccelerationStructureNVX & operator=( std::nullptr_t )
-    {
-      m_accelerationStructureNVX = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( AccelerationStructureNVX const & rhs ) const
-    {
-      return m_accelerationStructureNVX == rhs.m_accelerationStructureNVX;
-    }
-
-    bool operator!=(AccelerationStructureNVX const & rhs ) const
-    {
-      return m_accelerationStructureNVX != rhs.m_accelerationStructureNVX;
-    }
-
-    bool operator<(AccelerationStructureNVX const & rhs ) const
-    {
-      return m_accelerationStructureNVX < rhs.m_accelerationStructureNVX;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNVX() const
-    {
-      return m_accelerationStructureNVX;
-    }
-
-    explicit operator bool() const
-    {
-      return m_accelerationStructureNVX != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_accelerationStructureNVX == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkAccelerationStructureNVX m_accelerationStructureNVX;
-  };
-
-  static_assert( sizeof( AccelerationStructureNVX ) == sizeof( VkAccelerationStructureNVX ), "handle and wrapper have different size!" );
-
-  class DisplayKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DisplayKHR()
-      : m_displayKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t )
-      : m_displayKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR )
-      : m_displayKHR( displayKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DisplayKHR & operator=(VkDisplayKHR displayKHR)
-    {
-      m_displayKHR = displayKHR;
-      return *this; 
-    }
-#endif
-
-    DisplayKHR & operator=( std::nullptr_t )
-    {
-      m_displayKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR == rhs.m_displayKHR;
-    }
-
-    bool operator!=(DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR != rhs.m_displayKHR;
-    }
-
-    bool operator<(DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR < rhs.m_displayKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const
-    {
-      return m_displayKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_displayKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_displayKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDisplayKHR m_displayKHR;
-  };
-
-  static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
-
-  class DisplayModeKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DisplayModeKHR()
-      : m_displayModeKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t )
-      : m_displayModeKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR )
-      : m_displayModeKHR( displayModeKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR)
-    {
-      m_displayModeKHR = displayModeKHR;
-      return *this; 
-    }
-#endif
-
-    DisplayModeKHR & operator=( std::nullptr_t )
-    {
-      m_displayModeKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR == rhs.m_displayModeKHR;
-    }
-
-    bool operator!=(DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR != rhs.m_displayModeKHR;
-    }
-
-    bool operator<(DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR < rhs.m_displayModeKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const
-    {
-      return m_displayModeKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_displayModeKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_displayModeKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDisplayModeKHR m_displayModeKHR;
-  };
-
-  static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
-
-  class SurfaceKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR SurfaceKHR()
-      : m_surfaceKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t )
-      : m_surfaceKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR )
-      : m_surfaceKHR( surfaceKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR)
-    {
-      m_surfaceKHR = surfaceKHR;
-      return *this; 
-    }
-#endif
-
-    SurfaceKHR & operator=( std::nullptr_t )
-    {
-      m_surfaceKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR == rhs.m_surfaceKHR;
-    }
-
-    bool operator!=(SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR != rhs.m_surfaceKHR;
-    }
-
-    bool operator<(SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR < rhs.m_surfaceKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const
-    {
-      return m_surfaceKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_surfaceKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_surfaceKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSurfaceKHR m_surfaceKHR;
-  };
-
-  static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
-
-  class SwapchainKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR SwapchainKHR()
-      : m_swapchainKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t )
-      : m_swapchainKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR )
-      : m_swapchainKHR( swapchainKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR)
-    {
-      m_swapchainKHR = swapchainKHR;
-      return *this; 
-    }
-#endif
-
-    SwapchainKHR & operator=( std::nullptr_t )
-    {
-      m_swapchainKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR == rhs.m_swapchainKHR;
-    }
-
-    bool operator!=(SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR != rhs.m_swapchainKHR;
-    }
-
-    bool operator<(SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR < rhs.m_swapchainKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const
-    {
-      return m_swapchainKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_swapchainKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_swapchainKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSwapchainKHR m_swapchainKHR;
-  };
-
-  static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
-
-  class DebugReportCallbackEXT
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
-      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t )
-      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT )
-      : m_debugReportCallbackEXT( debugReportCallbackEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
-    {
-      m_debugReportCallbackEXT = debugReportCallbackEXT;
-      return *this; 
-    }
-#endif
-
-    DebugReportCallbackEXT & operator=( std::nullptr_t )
-    {
-      m_debugReportCallbackEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
-    }
-
-    bool operator!=(DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
-    }
-
-    bool operator<(DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const
-    {
-      return m_debugReportCallbackEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_debugReportCallbackEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_debugReportCallbackEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDebugReportCallbackEXT m_debugReportCallbackEXT;
-  };
-
-  static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
-
-  class DebugUtilsMessengerEXT
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
-      : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t )
-      : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT )
-      : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)
-    {
-      m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
-      return *this; 
-    }
-#endif
-
-    DebugUtilsMessengerEXT & operator=( std::nullptr_t )
-    {
-      m_debugUtilsMessengerEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DebugUtilsMessengerEXT const & rhs ) const
-    {
-      return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
-    }
-
-    bool operator!=(DebugUtilsMessengerEXT const & rhs ) const
-    {
-      return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
-    }
-
-    bool operator<(DebugUtilsMessengerEXT const & rhs ) const
-    {
-      return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const
-    {
-      return m_debugUtilsMessengerEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT;
-  };
-
-  static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
-
-  struct Offset2D
-  {
-    Offset2D( int32_t x_ = 0,
-              int32_t y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    Offset2D( VkOffset2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset2D ) );
-    }
-
-    Offset2D& operator=( VkOffset2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset2D ) );
-      return *this;
-    }
-    Offset2D& setX( int32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Offset2D& setY( int32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator VkOffset2D const&() const
-    {
-      return *reinterpret_cast<const VkOffset2D*>(this);
-    }
-
-    operator VkOffset2D &()
-    {
-      return *reinterpret_cast<VkOffset2D*>(this);
-    }
-
-    bool operator==( Offset2D const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( Offset2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    int32_t x;
-    int32_t y;
-  };
-  static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
-
-  struct Offset3D
-  {
-    Offset3D( int32_t x_ = 0,
-              int32_t y_ = 0,
-              int32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-    {
-    }
-
-    explicit Offset3D( Offset2D const& offset2D,
-                       int32_t z_ = 0 )
-      : x( offset2D.x )
-      , y( offset2D.y )
-      , z( z_ )
-    {}
-
-    Offset3D( VkOffset3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset3D ) );
-    }
-
-    Offset3D& operator=( VkOffset3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset3D ) );
-      return *this;
-    }
-    Offset3D& setX( int32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Offset3D& setY( int32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    Offset3D& setZ( int32_t z_ )
-    {
-      z = z_;
-      return *this;
-    }
-
-    operator VkOffset3D const&() const
-    {
-      return *reinterpret_cast<const VkOffset3D*>(this);
-    }
-
-    operator VkOffset3D &()
-    {
-      return *reinterpret_cast<VkOffset3D*>(this);
-    }
-
-    bool operator==( Offset3D const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( z == rhs.z );
-    }
-
-    bool operator!=( Offset3D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    int32_t x;
-    int32_t y;
-    int32_t z;
-  };
-  static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
-
-  struct Extent2D
-  {
-    Extent2D( uint32_t width_ = 0,
-              uint32_t height_ = 0 )
-      : width( width_ )
-      , height( height_ )
-    {
-    }
-
-    Extent2D( VkExtent2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent2D ) );
-    }
-
-    Extent2D& operator=( VkExtent2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent2D ) );
-      return *this;
-    }
-    Extent2D& setWidth( uint32_t width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Extent2D& setHeight( uint32_t height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    operator VkExtent2D const&() const
-    {
-      return *reinterpret_cast<const VkExtent2D*>(this);
-    }
-
-    operator VkExtent2D &()
-    {
-      return *reinterpret_cast<VkExtent2D*>(this);
-    }
-
-    bool operator==( Extent2D const& rhs ) const
-    {
-      return ( width == rhs.width )
-          && ( height == rhs.height );
-    }
-
-    bool operator!=( Extent2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t width;
-    uint32_t height;
-  };
-  static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
-
-  struct Extent3D
-  {
-    Extent3D( uint32_t width_ = 0,
-              uint32_t height_ = 0,
-              uint32_t depth_ = 0 )
-      : width( width_ )
-      , height( height_ )
-      , depth( depth_ )
-    {
-    }
-
-    explicit Extent3D( Extent2D const& extent2D,
-                       uint32_t depth_ = 0 )
-      : width( extent2D.width )
-      , height( extent2D.height )
-      , depth( depth_ )
-    {}
-
-    Extent3D( VkExtent3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent3D ) );
-    }
-
-    Extent3D& operator=( VkExtent3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent3D ) );
-      return *this;
-    }
-    Extent3D& setWidth( uint32_t width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Extent3D& setHeight( uint32_t height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    Extent3D& setDepth( uint32_t depth_ )
-    {
-      depth = depth_;
-      return *this;
-    }
-
-    operator VkExtent3D const&() const
-    {
-      return *reinterpret_cast<const VkExtent3D*>(this);
-    }
-
-    operator VkExtent3D &()
-    {
-      return *reinterpret_cast<VkExtent3D*>(this);
-    }
-
-    bool operator==( Extent3D const& rhs ) const
-    {
-      return ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( depth == rhs.depth );
-    }
-
-    bool operator!=( Extent3D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t width;
-    uint32_t height;
-    uint32_t depth;
-  };
-  static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
-
-  struct Viewport
-  {
-    Viewport( float x_ = 0,
-              float y_ = 0,
-              float width_ = 0,
-              float height_ = 0,
-              float minDepth_ = 0,
-              float maxDepth_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , width( width_ )
-      , height( height_ )
-      , minDepth( minDepth_ )
-      , maxDepth( maxDepth_ )
-    {
-    }
-
-    Viewport( VkViewport const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Viewport ) );
-    }
-
-    Viewport& operator=( VkViewport const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Viewport ) );
-      return *this;
-    }
-    Viewport& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Viewport& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    Viewport& setWidth( float width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Viewport& setHeight( float height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    Viewport& setMinDepth( float minDepth_ )
-    {
-      minDepth = minDepth_;
-      return *this;
-    }
-
-    Viewport& setMaxDepth( float maxDepth_ )
-    {
-      maxDepth = maxDepth_;
-      return *this;
-    }
-
-    operator VkViewport const&() const
-    {
-      return *reinterpret_cast<const VkViewport*>(this);
-    }
-
-    operator VkViewport &()
-    {
-      return *reinterpret_cast<VkViewport*>(this);
-    }
-
-    bool operator==( Viewport const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( minDepth == rhs.minDepth )
-          && ( maxDepth == rhs.maxDepth );
-    }
-
-    bool operator!=( Viewport const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-    float width;
-    float height;
-    float minDepth;
-    float maxDepth;
-  };
-  static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
-
-  struct Rect2D
-  {
-    Rect2D( Offset2D offset_ = Offset2D(),
-            Extent2D extent_ = Extent2D() )
-      : offset( offset_ )
-      , extent( extent_ )
-    {
-    }
-
-    Rect2D( VkRect2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Rect2D ) );
-    }
-
-    Rect2D& operator=( VkRect2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Rect2D ) );
-      return *this;
-    }
-    Rect2D& setOffset( Offset2D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    Rect2D& setExtent( Extent2D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    operator VkRect2D const&() const
-    {
-      return *reinterpret_cast<const VkRect2D*>(this);
-    }
-
-    operator VkRect2D &()
-    {
-      return *reinterpret_cast<VkRect2D*>(this);
-    }
-
-    bool operator==( Rect2D const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( extent == rhs.extent );
-    }
-
-    bool operator!=( Rect2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Offset2D offset;
-    Extent2D extent;
-  };
-  static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
-
-  struct ClearRect
-  {
-    ClearRect( Rect2D rect_ = Rect2D(),
-               uint32_t baseArrayLayer_ = 0,
-               uint32_t layerCount_ = 0 )
-      : rect( rect_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
-    {
-    }
-
-    ClearRect( VkClearRect const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearRect ) );
-    }
-
-    ClearRect& operator=( VkClearRect const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearRect ) );
-      return *this;
-    }
-    ClearRect& setRect( Rect2D rect_ )
-    {
-      rect = rect_;
-      return *this;
-    }
-
-    ClearRect& setBaseArrayLayer( uint32_t baseArrayLayer_ )
-    {
-      baseArrayLayer = baseArrayLayer_;
-      return *this;
-    }
-
-    ClearRect& setLayerCount( uint32_t layerCount_ )
-    {
-      layerCount = layerCount_;
-      return *this;
-    }
-
-    operator VkClearRect const&() const
-    {
-      return *reinterpret_cast<const VkClearRect*>(this);
-    }
-
-    operator VkClearRect &()
-    {
-      return *reinterpret_cast<VkClearRect*>(this);
-    }
-
-    bool operator==( ClearRect const& rhs ) const
-    {
-      return ( rect == rhs.rect )
-          && ( baseArrayLayer == rhs.baseArrayLayer )
-          && ( layerCount == rhs.layerCount );
-    }
-
-    bool operator!=( ClearRect const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Rect2D rect;
-    uint32_t baseArrayLayer;
-    uint32_t layerCount;
-  };
-  static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
-
-  struct ExtensionProperties
-  {
-    operator VkExtensionProperties const&() const
-    {
-      return *reinterpret_cast<const VkExtensionProperties*>(this);
-    }
-
-    operator VkExtensionProperties &()
-    {
-      return *reinterpret_cast<VkExtensionProperties*>(this);
-    }
-
-    bool operator==( ExtensionProperties const& rhs ) const
-    {
-      return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
-          && ( specVersion == rhs.specVersion );
-    }
-
-    bool operator!=( ExtensionProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t specVersion;
-  };
-  static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
-
-  struct LayerProperties
-  {
-    operator VkLayerProperties const&() const
-    {
-      return *reinterpret_cast<const VkLayerProperties*>(this);
-    }
-
-    operator VkLayerProperties &()
-    {
-      return *reinterpret_cast<VkLayerProperties*>(this);
-    }
-
-    bool operator==( LayerProperties const& rhs ) const
-    {
-      return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
-          && ( specVersion == rhs.specVersion )
-          && ( implementationVersion == rhs.implementationVersion )
-          && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
-    }
-
-    bool operator!=( LayerProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    char layerName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t specVersion;
-    uint32_t implementationVersion;
-    char description[VK_MAX_DESCRIPTION_SIZE];
-  };
-  static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
-
-  struct AllocationCallbacks
-  {
-    AllocationCallbacks( void* pUserData_ = nullptr,
-                         PFN_vkAllocationFunction pfnAllocation_ = nullptr,
-                         PFN_vkReallocationFunction pfnReallocation_ = nullptr,
-                         PFN_vkFreeFunction pfnFree_ = nullptr,
-                         PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr,
-                         PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
-      : pUserData( pUserData_ )
-      , pfnAllocation( pfnAllocation_ )
-      , pfnReallocation( pfnReallocation_ )
-      , pfnFree( pfnFree_ )
-      , pfnInternalAllocation( pfnInternalAllocation_ )
-      , pfnInternalFree( pfnInternalFree_ )
-    {
-    }
-
-    AllocationCallbacks( VkAllocationCallbacks const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
-    }
-
-    AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
-      return *this;
-    }
-    AllocationCallbacks& setPUserData( void* pUserData_ )
-    {
-      pUserData = pUserData_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ )
-    {
-      pfnAllocation = pfnAllocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ )
-    {
-      pfnReallocation = pfnReallocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnFree( PFN_vkFreeFunction pfnFree_ )
-    {
-      pfnFree = pfnFree_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ )
-    {
-      pfnInternalAllocation = pfnInternalAllocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ )
-    {
-      pfnInternalFree = pfnInternalFree_;
-      return *this;
-    }
-
-    operator VkAllocationCallbacks const&() const
-    {
-      return *reinterpret_cast<const VkAllocationCallbacks*>(this);
-    }
-
-    operator VkAllocationCallbacks &()
-    {
-      return *reinterpret_cast<VkAllocationCallbacks*>(this);
-    }
-
-    bool operator==( AllocationCallbacks const& rhs ) const
-    {
-      return ( pUserData == rhs.pUserData )
-          && ( pfnAllocation == rhs.pfnAllocation )
-          && ( pfnReallocation == rhs.pfnReallocation )
-          && ( pfnFree == rhs.pfnFree )
-          && ( pfnInternalAllocation == rhs.pfnInternalAllocation )
-          && ( pfnInternalFree == rhs.pfnInternalFree );
-    }
-
-    bool operator!=( AllocationCallbacks const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    void* pUserData;
-    PFN_vkAllocationFunction pfnAllocation;
-    PFN_vkReallocationFunction pfnReallocation;
-    PFN_vkFreeFunction pfnFree;
-    PFN_vkInternalAllocationNotification pfnInternalAllocation;
-    PFN_vkInternalFreeNotification pfnInternalFree;
-  };
-  static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
-
-  struct MemoryRequirements
-  {
-    operator VkMemoryRequirements const&() const
-    {
-      return *reinterpret_cast<const VkMemoryRequirements*>(this);
-    }
-
-    operator VkMemoryRequirements &()
-    {
-      return *reinterpret_cast<VkMemoryRequirements*>(this);
-    }
-
-    bool operator==( MemoryRequirements const& rhs ) const
-    {
-      return ( size == rhs.size )
-          && ( alignment == rhs.alignment )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryRequirements const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize size;
-    DeviceSize alignment;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
-
-  struct DescriptorBufferInfo
-  {
-    DescriptorBufferInfo( Buffer buffer_ = Buffer(),
-                          DeviceSize offset_ = 0,
-                          DeviceSize range_ = 0 )
-      : buffer( buffer_ )
-      , offset( offset_ )
-      , range( range_ )
-    {
-    }
-
-    DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
-    }
-
-    DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
-      return *this;
-    }
-    DescriptorBufferInfo& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    DescriptorBufferInfo& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    DescriptorBufferInfo& setRange( DeviceSize range_ )
-    {
-      range = range_;
-      return *this;
-    }
-
-    operator VkDescriptorBufferInfo const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorBufferInfo*>(this);
-    }
-
-    operator VkDescriptorBufferInfo &()
-    {
-      return *reinterpret_cast<VkDescriptorBufferInfo*>(this);
-    }
-
-    bool operator==( DescriptorBufferInfo const& rhs ) const
-    {
-      return ( buffer == rhs.buffer )
-          && ( offset == rhs.offset )
-          && ( range == rhs.range );
-    }
-
-    bool operator!=( DescriptorBufferInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Buffer buffer;
-    DeviceSize offset;
-    DeviceSize range;
-  };
-  static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
-
-  struct SubresourceLayout
-  {
-    operator VkSubresourceLayout const&() const
-    {
-      return *reinterpret_cast<const VkSubresourceLayout*>(this);
-    }
-
-    operator VkSubresourceLayout &()
-    {
-      return *reinterpret_cast<VkSubresourceLayout*>(this);
-    }
-
-    bool operator==( SubresourceLayout const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( size == rhs.size )
-          && ( rowPitch == rhs.rowPitch )
-          && ( arrayPitch == rhs.arrayPitch )
-          && ( depthPitch == rhs.depthPitch );
-    }
-
-    bool operator!=( SubresourceLayout const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize offset;
-    DeviceSize size;
-    DeviceSize rowPitch;
-    DeviceSize arrayPitch;
-    DeviceSize depthPitch;
-  };
-  static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
-
-  struct BufferCopy
-  {
-    BufferCopy( DeviceSize srcOffset_ = 0,
-                DeviceSize dstOffset_ = 0,
-                DeviceSize size_ = 0 )
-      : srcOffset( srcOffset_ )
-      , dstOffset( dstOffset_ )
-      , size( size_ )
-    {
-    }
-
-    BufferCopy( VkBufferCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCopy ) );
-    }
-
-    BufferCopy& operator=( VkBufferCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCopy ) );
-      return *this;
-    }
-    BufferCopy& setSrcOffset( DeviceSize srcOffset_ )
-    {
-      srcOffset = srcOffset_;
-      return *this;
-    }
-
-    BufferCopy& setDstOffset( DeviceSize dstOffset_ )
-    {
-      dstOffset = dstOffset_;
-      return *this;
-    }
-
-    BufferCopy& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator VkBufferCopy const&() const
-    {
-      return *reinterpret_cast<const VkBufferCopy*>(this);
-    }
-
-    operator VkBufferCopy &()
-    {
-      return *reinterpret_cast<VkBufferCopy*>(this);
-    }
-
-    bool operator==( BufferCopy const& rhs ) const
-    {
-      return ( srcOffset == rhs.srcOffset )
-          && ( dstOffset == rhs.dstOffset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( BufferCopy const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize srcOffset;
-    DeviceSize dstOffset;
-    DeviceSize size;
-  };
-  static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
-
-  struct SpecializationMapEntry
-  {
-    SpecializationMapEntry( uint32_t constantID_ = 0,
-                            uint32_t offset_ = 0,
-                            size_t size_ = 0 )
-      : constantID( constantID_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
-    }
-
-    SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
-      return *this;
-    }
-    SpecializationMapEntry& setConstantID( uint32_t constantID_ )
-    {
-      constantID = constantID_;
-      return *this;
-    }
-
-    SpecializationMapEntry& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    SpecializationMapEntry& setSize( size_t size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator VkSpecializationMapEntry const&() const
-    {
-      return *reinterpret_cast<const VkSpecializationMapEntry*>(this);
-    }
-
-    operator VkSpecializationMapEntry &()
-    {
-      return *reinterpret_cast<VkSpecializationMapEntry*>(this);
-    }
-
-    bool operator==( SpecializationMapEntry const& rhs ) const
-    {
-      return ( constantID == rhs.constantID )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( SpecializationMapEntry const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t constantID;
-    uint32_t offset;
-    size_t size;
-  };
-  static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
-
-  struct SpecializationInfo
-  {
-    SpecializationInfo( uint32_t mapEntryCount_ = 0,
-                        const SpecializationMapEntry* pMapEntries_ = nullptr,
-                        size_t dataSize_ = 0,
-                        const void* pData_ = nullptr )
-      : mapEntryCount( mapEntryCount_ )
-      , pMapEntries( pMapEntries_ )
-      , dataSize( dataSize_ )
-      , pData( pData_ )
-    {
-    }
-
-    SpecializationInfo( VkSpecializationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
-    }
-
-    SpecializationInfo& operator=( VkSpecializationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
-      return *this;
-    }
-    SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ )
-    {
-      mapEntryCount = mapEntryCount_;
-      return *this;
-    }
-
-    SpecializationInfo& setPMapEntries( const SpecializationMapEntry* pMapEntries_ )
-    {
-      pMapEntries = pMapEntries_;
-      return *this;
-    }
-
-    SpecializationInfo& setDataSize( size_t dataSize_ )
-    {
-      dataSize = dataSize_;
-      return *this;
-    }
-
-    SpecializationInfo& setPData( const void* pData_ )
-    {
-      pData = pData_;
-      return *this;
-    }
-
-    operator VkSpecializationInfo const&() const
-    {
-      return *reinterpret_cast<const VkSpecializationInfo*>(this);
-    }
-
-    operator VkSpecializationInfo &()
-    {
-      return *reinterpret_cast<VkSpecializationInfo*>(this);
-    }
-
-    bool operator==( SpecializationInfo const& rhs ) const
-    {
-      return ( mapEntryCount == rhs.mapEntryCount )
-          && ( pMapEntries == rhs.pMapEntries )
-          && ( dataSize == rhs.dataSize )
-          && ( pData == rhs.pData );
-    }
-
-    bool operator!=( SpecializationInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t mapEntryCount;
-    const SpecializationMapEntry* pMapEntries;
-    size_t dataSize;
-    const void* pData;
-  };
-  static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
-
-  union ClearColorValue
-  {
-    ClearColorValue( const std::array<float,4>& float32_ = { {0} } )
-    {
-      memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
-    }
-
-    ClearColorValue( const std::array<int32_t,4>& int32_ )
-    {
-      memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
-    }
-
-    ClearColorValue( const std::array<uint32_t,4>& uint32_ )
-    {
-      memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
-    }
-
-    ClearColorValue& setFloat32( std::array<float,4> float32_ )
-    {
-      memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    ClearColorValue& setInt32( std::array<int32_t,4> int32_ )
-    {
-      memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
-      return *this;
-    }
-
-    ClearColorValue& setUint32( std::array<uint32_t,4> uint32_ )
-    {
-      memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
-      return *this;
-    }
-
-    operator VkClearColorValue const&() const
-    {
-      return *reinterpret_cast<const VkClearColorValue*>(this);
-    }
-
-    operator VkClearColorValue &()
-    {
-      return *reinterpret_cast<VkClearColorValue*>(this);
-    }
-
-    float float32[4];
-    int32_t int32[4];
-    uint32_t uint32[4];
-  };
-
-  struct ClearDepthStencilValue
-  {
-    ClearDepthStencilValue( float depth_ = 0,
-                            uint32_t stencil_ = 0 )
-      : depth( depth_ )
-      , stencil( stencil_ )
-    {
-    }
-
-    ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
-    }
-
-    ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
-      return *this;
-    }
-    ClearDepthStencilValue& setDepth( float depth_ )
-    {
-      depth = depth_;
-      return *this;
-    }
-
-    ClearDepthStencilValue& setStencil( uint32_t stencil_ )
-    {
-      stencil = stencil_;
-      return *this;
-    }
-
-    operator VkClearDepthStencilValue const&() const
-    {
-      return *reinterpret_cast<const VkClearDepthStencilValue*>(this);
-    }
-
-    operator VkClearDepthStencilValue &()
-    {
-      return *reinterpret_cast<VkClearDepthStencilValue*>(this);
-    }
-
-    bool operator==( ClearDepthStencilValue const& rhs ) const
-    {
-      return ( depth == rhs.depth )
-          && ( stencil == rhs.stencil );
-    }
-
-    bool operator!=( ClearDepthStencilValue const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float depth;
-    uint32_t stencil;
-  };
-  static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
-
-  union ClearValue
-  {
-    ClearValue( ClearColorValue color_ = ClearColorValue() )
-    {
-      color = color_;
-    }
-
-    ClearValue( ClearDepthStencilValue depthStencil_ )
-    {
-      depthStencil = depthStencil_;
-    }
-
-    ClearValue& setColor( ClearColorValue color_ )
-    {
-      color = color_;
-      return *this;
-    }
-
-    ClearValue& setDepthStencil( ClearDepthStencilValue depthStencil_ )
-    {
-      depthStencil = depthStencil_;
-      return *this;
-    }
-
-    operator VkClearValue const&() const
-    {
-      return *reinterpret_cast<const VkClearValue*>(this);
-    }
-
-    operator VkClearValue &()
-    {
-      return *reinterpret_cast<VkClearValue*>(this);
-    }
-
-#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-    ClearColorValue color;
-    ClearDepthStencilValue depthStencil;
-#else
-    VkClearColorValue color;
-    VkClearDepthStencilValue depthStencil;
-#endif  // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-  };
-
-  struct PhysicalDeviceFeatures
-  {
-    PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0,
-                            Bool32 fullDrawIndexUint32_ = 0,
-                            Bool32 imageCubeArray_ = 0,
-                            Bool32 independentBlend_ = 0,
-                            Bool32 geometryShader_ = 0,
-                            Bool32 tessellationShader_ = 0,
-                            Bool32 sampleRateShading_ = 0,
-                            Bool32 dualSrcBlend_ = 0,
-                            Bool32 logicOp_ = 0,
-                            Bool32 multiDrawIndirect_ = 0,
-                            Bool32 drawIndirectFirstInstance_ = 0,
-                            Bool32 depthClamp_ = 0,
-                            Bool32 depthBiasClamp_ = 0,
-                            Bool32 fillModeNonSolid_ = 0,
-                            Bool32 depthBounds_ = 0,
-                            Bool32 wideLines_ = 0,
-                            Bool32 largePoints_ = 0,
-                            Bool32 alphaToOne_ = 0,
-                            Bool32 multiViewport_ = 0,
-                            Bool32 samplerAnisotropy_ = 0,
-                            Bool32 textureCompressionETC2_ = 0,
-                            Bool32 textureCompressionASTC_LDR_ = 0,
-                            Bool32 textureCompressionBC_ = 0,
-                            Bool32 occlusionQueryPrecise_ = 0,
-                            Bool32 pipelineStatisticsQuery_ = 0,
-                            Bool32 vertexPipelineStoresAndAtomics_ = 0,
-                            Bool32 fragmentStoresAndAtomics_ = 0,
-                            Bool32 shaderTessellationAndGeometryPointSize_ = 0,
-                            Bool32 shaderImageGatherExtended_ = 0,
-                            Bool32 shaderStorageImageExtendedFormats_ = 0,
-                            Bool32 shaderStorageImageMultisample_ = 0,
-                            Bool32 shaderStorageImageReadWithoutFormat_ = 0,
-                            Bool32 shaderStorageImageWriteWithoutFormat_ = 0,
-                            Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0,
-                            Bool32 shaderSampledImageArrayDynamicIndexing_ = 0,
-                            Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0,
-                            Bool32 shaderStorageImageArrayDynamicIndexing_ = 0,
-                            Bool32 shaderClipDistance_ = 0,
-                            Bool32 shaderCullDistance_ = 0,
-                            Bool32 shaderFloat64_ = 0,
-                            Bool32 shaderInt64_ = 0,
-                            Bool32 shaderInt16_ = 0,
-                            Bool32 shaderResourceResidency_ = 0,
-                            Bool32 shaderResourceMinLod_ = 0,
-                            Bool32 sparseBinding_ = 0,
-                            Bool32 sparseResidencyBuffer_ = 0,
-                            Bool32 sparseResidencyImage2D_ = 0,
-                            Bool32 sparseResidencyImage3D_ = 0,
-                            Bool32 sparseResidency2Samples_ = 0,
-                            Bool32 sparseResidency4Samples_ = 0,
-                            Bool32 sparseResidency8Samples_ = 0,
-                            Bool32 sparseResidency16Samples_ = 0,
-                            Bool32 sparseResidencyAliased_ = 0,
-                            Bool32 variableMultisampleRate_ = 0,
-                            Bool32 inheritedQueries_ = 0 )
-      : robustBufferAccess( robustBufferAccess_ )
-      , fullDrawIndexUint32( fullDrawIndexUint32_ )
-      , imageCubeArray( imageCubeArray_ )
-      , independentBlend( independentBlend_ )
-      , geometryShader( geometryShader_ )
-      , tessellationShader( tessellationShader_ )
-      , sampleRateShading( sampleRateShading_ )
-      , dualSrcBlend( dualSrcBlend_ )
-      , logicOp( logicOp_ )
-      , multiDrawIndirect( multiDrawIndirect_ )
-      , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
-      , depthClamp( depthClamp_ )
-      , depthBiasClamp( depthBiasClamp_ )
-      , fillModeNonSolid( fillModeNonSolid_ )
-      , depthBounds( depthBounds_ )
-      , wideLines( wideLines_ )
-      , largePoints( largePoints_ )
-      , alphaToOne( alphaToOne_ )
-      , multiViewport( multiViewport_ )
-      , samplerAnisotropy( samplerAnisotropy_ )
-      , textureCompressionETC2( textureCompressionETC2_ )
-      , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
-      , textureCompressionBC( textureCompressionBC_ )
-      , occlusionQueryPrecise( occlusionQueryPrecise_ )
-      , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
-      , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
-      , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
-      , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
-      , shaderImageGatherExtended( shaderImageGatherExtended_ )
-      , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
-      , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
-      , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
-      , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
-      , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
-      , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
-      , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
-      , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
-      , shaderClipDistance( shaderClipDistance_ )
-      , shaderCullDistance( shaderCullDistance_ )
-      , shaderFloat64( shaderFloat64_ )
-      , shaderInt64( shaderInt64_ )
-      , shaderInt16( shaderInt16_ )
-      , shaderResourceResidency( shaderResourceResidency_ )
-      , shaderResourceMinLod( shaderResourceMinLod_ )
-      , sparseBinding( sparseBinding_ )
-      , sparseResidencyBuffer( sparseResidencyBuffer_ )
-      , sparseResidencyImage2D( sparseResidencyImage2D_ )
-      , sparseResidencyImage3D( sparseResidencyImage3D_ )
-      , sparseResidency2Samples( sparseResidency2Samples_ )
-      , sparseResidency4Samples( sparseResidency4Samples_ )
-      , sparseResidency8Samples( sparseResidency8Samples_ )
-      , sparseResidency16Samples( sparseResidency16Samples_ )
-      , sparseResidencyAliased( sparseResidencyAliased_ )
-      , variableMultisampleRate( variableMultisampleRate_ )
-      , inheritedQueries( inheritedQueries_ )
-    {
-    }
-
-    PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
-    }
-
-    PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ )
-    {
-      robustBufferAccess = robustBufferAccess_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ )
-    {
-      fullDrawIndexUint32 = fullDrawIndexUint32_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setImageCubeArray( Bool32 imageCubeArray_ )
-    {
-      imageCubeArray = imageCubeArray_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setIndependentBlend( Bool32 independentBlend_ )
-    {
-      independentBlend = independentBlend_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setGeometryShader( Bool32 geometryShader_ )
-    {
-      geometryShader = geometryShader_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTessellationShader( Bool32 tessellationShader_ )
-    {
-      tessellationShader = tessellationShader_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSampleRateShading( Bool32 sampleRateShading_ )
-    {
-      sampleRateShading = sampleRateShading_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDualSrcBlend( Bool32 dualSrcBlend_ )
-    {
-      dualSrcBlend = dualSrcBlend_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setLogicOp( Bool32 logicOp_ )
-    {
-      logicOp = logicOp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setMultiDrawIndirect( Bool32 multiDrawIndirect_ )
-    {
-      multiDrawIndirect = multiDrawIndirect_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ )
-    {
-      drawIndirectFirstInstance = drawIndirectFirstInstance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthClamp( Bool32 depthClamp_ )
-    {
-      depthClamp = depthClamp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthBiasClamp( Bool32 depthBiasClamp_ )
-    {
-      depthBiasClamp = depthBiasClamp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFillModeNonSolid( Bool32 fillModeNonSolid_ )
-    {
-      fillModeNonSolid = fillModeNonSolid_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthBounds( Bool32 depthBounds_ )
-    {
-      depthBounds = depthBounds_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setWideLines( Bool32 wideLines_ )
-    {
-      wideLines = wideLines_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setLargePoints( Bool32 largePoints_ )
-    {
-      largePoints = largePoints_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setAlphaToOne( Bool32 alphaToOne_ )
-    {
-      alphaToOne = alphaToOne_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setMultiViewport( Bool32 multiViewport_ )
-    {
-      multiViewport = multiViewport_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSamplerAnisotropy( Bool32 samplerAnisotropy_ )
-    {
-      samplerAnisotropy = samplerAnisotropy_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionETC2( Bool32 textureCompressionETC2_ )
-    {
-      textureCompressionETC2 = textureCompressionETC2_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ )
-    {
-      textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionBC( Bool32 textureCompressionBC_ )
-    {
-      textureCompressionBC = textureCompressionBC_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ )
-    {
-      occlusionQueryPrecise = occlusionQueryPrecise_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ )
-    {
-      pipelineStatisticsQuery = pipelineStatisticsQuery_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ )
-    {
-      vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ )
-    {
-      fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ )
-    {
-      shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ )
-    {
-      shaderImageGatherExtended = shaderImageGatherExtended_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ )
-    {
-      shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ )
-    {
-      shaderStorageImageMultisample = shaderStorageImageMultisample_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ )
-    {
-      shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ )
-    {
-      shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ )
-    {
-      shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ )
-    {
-      shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ )
-    {
-      shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ )
-    {
-      shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderClipDistance( Bool32 shaderClipDistance_ )
-    {
-      shaderClipDistance = shaderClipDistance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderCullDistance( Bool32 shaderCullDistance_ )
-    {
-      shaderCullDistance = shaderCullDistance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderFloat64( Bool32 shaderFloat64_ )
-    {
-      shaderFloat64 = shaderFloat64_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderInt64( Bool32 shaderInt64_ )
-    {
-      shaderInt64 = shaderInt64_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderInt16( Bool32 shaderInt16_ )
-    {
-      shaderInt16 = shaderInt16_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderResourceResidency( Bool32 shaderResourceResidency_ )
-    {
-      shaderResourceResidency = shaderResourceResidency_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderResourceMinLod( Bool32 shaderResourceMinLod_ )
-    {
-      shaderResourceMinLod = shaderResourceMinLod_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseBinding( Bool32 sparseBinding_ )
-    {
-      sparseBinding = sparseBinding_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ )
-    {
-      sparseResidencyBuffer = sparseResidencyBuffer_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ )
-    {
-      sparseResidencyImage2D = sparseResidencyImage2D_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ )
-    {
-      sparseResidencyImage3D = sparseResidencyImage3D_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency2Samples( Bool32 sparseResidency2Samples_ )
-    {
-      sparseResidency2Samples = sparseResidency2Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency4Samples( Bool32 sparseResidency4Samples_ )
-    {
-      sparseResidency4Samples = sparseResidency4Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency8Samples( Bool32 sparseResidency8Samples_ )
-    {
-      sparseResidency8Samples = sparseResidency8Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency16Samples( Bool32 sparseResidency16Samples_ )
-    {
-      sparseResidency16Samples = sparseResidency16Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyAliased( Bool32 sparseResidencyAliased_ )
-    {
-      sparseResidencyAliased = sparseResidencyAliased_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setVariableMultisampleRate( Bool32 variableMultisampleRate_ )
-    {
-      variableMultisampleRate = variableMultisampleRate_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setInheritedQueries( Bool32 inheritedQueries_ )
-    {
-      inheritedQueries = inheritedQueries_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceFeatures const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this);
-    }
-
-    operator VkPhysicalDeviceFeatures &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceFeatures const& rhs ) const
-    {
-      return ( robustBufferAccess == rhs.robustBufferAccess )
-          && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 )
-          && ( imageCubeArray == rhs.imageCubeArray )
-          && ( independentBlend == rhs.independentBlend )
-          && ( geometryShader == rhs.geometryShader )
-          && ( tessellationShader == rhs.tessellationShader )
-          && ( sampleRateShading == rhs.sampleRateShading )
-          && ( dualSrcBlend == rhs.dualSrcBlend )
-          && ( logicOp == rhs.logicOp )
-          && ( multiDrawIndirect == rhs.multiDrawIndirect )
-          && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance )
-          && ( depthClamp == rhs.depthClamp )
-          && ( depthBiasClamp == rhs.depthBiasClamp )
-          && ( fillModeNonSolid == rhs.fillModeNonSolid )
-          && ( depthBounds == rhs.depthBounds )
-          && ( wideLines == rhs.wideLines )
-          && ( largePoints == rhs.largePoints )
-          && ( alphaToOne == rhs.alphaToOne )
-          && ( multiViewport == rhs.multiViewport )
-          && ( samplerAnisotropy == rhs.samplerAnisotropy )
-          && ( textureCompressionETC2 == rhs.textureCompressionETC2 )
-          && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR )
-          && ( textureCompressionBC == rhs.textureCompressionBC )
-          && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise )
-          && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery )
-          && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics )
-          && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics )
-          && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize )
-          && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended )
-          && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats )
-          && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample )
-          && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat )
-          && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat )
-          && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing )
-          && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing )
-          && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing )
-          && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing )
-          && ( shaderClipDistance == rhs.shaderClipDistance )
-          && ( shaderCullDistance == rhs.shaderCullDistance )
-          && ( shaderFloat64 == rhs.shaderFloat64 )
-          && ( shaderInt64 == rhs.shaderInt64 )
-          && ( shaderInt16 == rhs.shaderInt16 )
-          && ( shaderResourceResidency == rhs.shaderResourceResidency )
-          && ( shaderResourceMinLod == rhs.shaderResourceMinLod )
-          && ( sparseBinding == rhs.sparseBinding )
-          && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer )
-          && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D )
-          && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D )
-          && ( sparseResidency2Samples == rhs.sparseResidency2Samples )
-          && ( sparseResidency4Samples == rhs.sparseResidency4Samples )
-          && ( sparseResidency8Samples == rhs.sparseResidency8Samples )
-          && ( sparseResidency16Samples == rhs.sparseResidency16Samples )
-          && ( sparseResidencyAliased == rhs.sparseResidencyAliased )
-          && ( variableMultisampleRate == rhs.variableMultisampleRate )
-          && ( inheritedQueries == rhs.inheritedQueries );
-    }
-
-    bool operator!=( PhysicalDeviceFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 robustBufferAccess;
-    Bool32 fullDrawIndexUint32;
-    Bool32 imageCubeArray;
-    Bool32 independentBlend;
-    Bool32 geometryShader;
-    Bool32 tessellationShader;
-    Bool32 sampleRateShading;
-    Bool32 dualSrcBlend;
-    Bool32 logicOp;
-    Bool32 multiDrawIndirect;
-    Bool32 drawIndirectFirstInstance;
-    Bool32 depthClamp;
-    Bool32 depthBiasClamp;
-    Bool32 fillModeNonSolid;
-    Bool32 depthBounds;
-    Bool32 wideLines;
-    Bool32 largePoints;
-    Bool32 alphaToOne;
-    Bool32 multiViewport;
-    Bool32 samplerAnisotropy;
-    Bool32 textureCompressionETC2;
-    Bool32 textureCompressionASTC_LDR;
-    Bool32 textureCompressionBC;
-    Bool32 occlusionQueryPrecise;
-    Bool32 pipelineStatisticsQuery;
-    Bool32 vertexPipelineStoresAndAtomics;
-    Bool32 fragmentStoresAndAtomics;
-    Bool32 shaderTessellationAndGeometryPointSize;
-    Bool32 shaderImageGatherExtended;
-    Bool32 shaderStorageImageExtendedFormats;
-    Bool32 shaderStorageImageMultisample;
-    Bool32 shaderStorageImageReadWithoutFormat;
-    Bool32 shaderStorageImageWriteWithoutFormat;
-    Bool32 shaderUniformBufferArrayDynamicIndexing;
-    Bool32 shaderSampledImageArrayDynamicIndexing;
-    Bool32 shaderStorageBufferArrayDynamicIndexing;
-    Bool32 shaderStorageImageArrayDynamicIndexing;
-    Bool32 shaderClipDistance;
-    Bool32 shaderCullDistance;
-    Bool32 shaderFloat64;
-    Bool32 shaderInt64;
-    Bool32 shaderInt16;
-    Bool32 shaderResourceResidency;
-    Bool32 shaderResourceMinLod;
-    Bool32 sparseBinding;
-    Bool32 sparseResidencyBuffer;
-    Bool32 sparseResidencyImage2D;
-    Bool32 sparseResidencyImage3D;
-    Bool32 sparseResidency2Samples;
-    Bool32 sparseResidency4Samples;
-    Bool32 sparseResidency8Samples;
-    Bool32 sparseResidency16Samples;
-    Bool32 sparseResidencyAliased;
-    Bool32 variableMultisampleRate;
-    Bool32 inheritedQueries;
-  };
-  static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSparseProperties
-  {
-    operator VkPhysicalDeviceSparseProperties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
-    }
-
-    operator VkPhysicalDeviceSparseProperties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSparseProperties const& rhs ) const
-    {
-      return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape )
-          && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape )
-          && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape )
-          && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize )
-          && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
-    }
-
-    bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 residencyStandard2DBlockShape;
-    Bool32 residencyStandard2DMultisampleBlockShape;
-    Bool32 residencyStandard3DBlockShape;
-    Bool32 residencyAlignedMipSize;
-    Bool32 residencyNonResidentStrict;
-  };
-  static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
-
-  struct DrawIndirectCommand
-  {
-    DrawIndirectCommand( uint32_t vertexCount_ = 0,
-                         uint32_t instanceCount_ = 0,
-                         uint32_t firstVertex_ = 0,
-                         uint32_t firstInstance_ = 0 )
-      : vertexCount( vertexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstVertex( firstVertex_ )
-      , firstInstance( firstInstance_ )
-    {
-    }
-
-    DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
-    }
-
-    DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
-      return *this;
-    }
-    DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ )
-    {
-      vertexCount = vertexCount_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
-    {
-      instanceCount = instanceCount_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setFirstVertex( uint32_t firstVertex_ )
-    {
-      firstVertex = firstVertex_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
-    {
-      firstInstance = firstInstance_;
-      return *this;
-    }
-
-    operator VkDrawIndirectCommand const&() const
-    {
-      return *reinterpret_cast<const VkDrawIndirectCommand*>(this);
-    }
-
-    operator VkDrawIndirectCommand &()
-    {
-      return *reinterpret_cast<VkDrawIndirectCommand*>(this);
-    }
-
-    bool operator==( DrawIndirectCommand const& rhs ) const
-    {
-      return ( vertexCount == rhs.vertexCount )
-          && ( instanceCount == rhs.instanceCount )
-          && ( firstVertex == rhs.firstVertex )
-          && ( firstInstance == rhs.firstInstance );
-    }
-
-    bool operator!=( DrawIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t vertexCount;
-    uint32_t instanceCount;
-    uint32_t firstVertex;
-    uint32_t firstInstance;
-  };
-  static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DrawIndexedIndirectCommand
-  {
-    DrawIndexedIndirectCommand( uint32_t indexCount_ = 0,
-                                uint32_t instanceCount_ = 0,
-                                uint32_t firstIndex_ = 0,
-                                int32_t vertexOffset_ = 0,
-                                uint32_t firstInstance_ = 0 )
-      : indexCount( indexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstIndex( firstIndex_ )
-      , vertexOffset( vertexOffset_ )
-      , firstInstance( firstInstance_ )
-    {
-    }
-
-    DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
-    }
-
-    DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
-      return *this;
-    }
-    DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ )
-    {
-      indexCount = indexCount_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
-    {
-      instanceCount = instanceCount_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setFirstIndex( uint32_t firstIndex_ )
-    {
-      firstIndex = firstIndex_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setVertexOffset( int32_t vertexOffset_ )
-    {
-      vertexOffset = vertexOffset_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
-    {
-      firstInstance = firstInstance_;
-      return *this;
-    }
-
-    operator VkDrawIndexedIndirectCommand const&() const
-    {
-      return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this);
-    }
-
-    operator VkDrawIndexedIndirectCommand &()
-    {
-      return *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this);
-    }
-
-    bool operator==( DrawIndexedIndirectCommand const& rhs ) const
-    {
-      return ( indexCount == rhs.indexCount )
-          && ( instanceCount == rhs.instanceCount )
-          && ( firstIndex == rhs.firstIndex )
-          && ( vertexOffset == rhs.vertexOffset )
-          && ( firstInstance == rhs.firstInstance );
-    }
-
-    bool operator!=( DrawIndexedIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t indexCount;
-    uint32_t instanceCount;
-    uint32_t firstIndex;
-    int32_t vertexOffset;
-    uint32_t firstInstance;
-  };
-  static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DispatchIndirectCommand
-  {
-    DispatchIndirectCommand( uint32_t x_ = 0,
-                             uint32_t y_ = 0,
-                             uint32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-    {
-    }
-
-    DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
-    }
-
-    DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
-      return *this;
-    }
-    DispatchIndirectCommand& setX( uint32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    DispatchIndirectCommand& setY( uint32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    DispatchIndirectCommand& setZ( uint32_t z_ )
-    {
-      z = z_;
-      return *this;
-    }
-
-    operator VkDispatchIndirectCommand const&() const
-    {
-      return *reinterpret_cast<const VkDispatchIndirectCommand*>(this);
-    }
-
-    operator VkDispatchIndirectCommand &()
-    {
-      return *reinterpret_cast<VkDispatchIndirectCommand*>(this);
-    }
-
-    bool operator==( DispatchIndirectCommand const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( z == rhs.z );
-    }
-
-    bool operator!=( DispatchIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t x;
-    uint32_t y;
-    uint32_t z;
-  };
-  static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DisplayPlanePropertiesKHR
-  {
-    operator VkDisplayPlanePropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
-    }
-
-    operator VkDisplayPlanePropertiesKHR &()
-    {
-      return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
-    {
-      return ( currentDisplay == rhs.currentDisplay )
-          && ( currentStackIndex == rhs.currentStackIndex );
-    }
-
-    bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayKHR currentDisplay;
-    uint32_t currentStackIndex;
-  };
-  static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayModeParametersKHR
-  {
-    DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(),
-                              uint32_t refreshRate_ = 0 )
-      : visibleRegion( visibleRegion_ )
-      , refreshRate( refreshRate_ )
-    {
-    }
-
-    DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
-    }
-
-    DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
-      return *this;
-    }
-    DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ )
-    {
-      visibleRegion = visibleRegion_;
-      return *this;
-    }
-
-    DisplayModeParametersKHR& setRefreshRate( uint32_t refreshRate_ )
-    {
-      refreshRate = refreshRate_;
-      return *this;
-    }
-
-    operator VkDisplayModeParametersKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this);
-    }
-
-    operator VkDisplayModeParametersKHR &()
-    {
-      return *reinterpret_cast<VkDisplayModeParametersKHR*>(this);
-    }
-
-    bool operator==( DisplayModeParametersKHR const& rhs ) const
-    {
-      return ( visibleRegion == rhs.visibleRegion )
-          && ( refreshRate == rhs.refreshRate );
-    }
-
-    bool operator!=( DisplayModeParametersKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Extent2D visibleRegion;
-    uint32_t refreshRate;
-  };
-  static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayModePropertiesKHR
-  {
-    operator VkDisplayModePropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
-    }
-
-    operator VkDisplayModePropertiesKHR &()
-    {
-      return *reinterpret_cast<VkDisplayModePropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayModePropertiesKHR const& rhs ) const
-    {
-      return ( displayMode == rhs.displayMode )
-          && ( parameters == rhs.parameters );
-    }
-
-    bool operator!=( DisplayModePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayModeKHR displayMode;
-    DisplayModeParametersKHR parameters;
-  };
-  static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct ConformanceVersionKHR
-  {
-    ConformanceVersionKHR( uint8_t major_ = 0,
-                           uint8_t minor_ = 0,
-                           uint8_t subminor_ = 0,
-                           uint8_t patch_ = 0 )
-      : major( major_ )
-      , minor( minor_ )
-      , subminor( subminor_ )
-      , patch( patch_ )
-    {
-    }
-
-    ConformanceVersionKHR( VkConformanceVersionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
-    }
-
-    ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
-      return *this;
-    }
-    ConformanceVersionKHR& setMajor( uint8_t major_ )
-    {
-      major = major_;
-      return *this;
-    }
-
-    ConformanceVersionKHR& setMinor( uint8_t minor_ )
-    {
-      minor = minor_;
-      return *this;
-    }
-
-    ConformanceVersionKHR& setSubminor( uint8_t subminor_ )
-    {
-      subminor = subminor_;
-      return *this;
-    }
-
-    ConformanceVersionKHR& setPatch( uint8_t patch_ )
-    {
-      patch = patch_;
-      return *this;
-    }
-
-    operator VkConformanceVersionKHR const&() const
-    {
-      return *reinterpret_cast<const VkConformanceVersionKHR*>(this);
-    }
-
-    operator VkConformanceVersionKHR &()
-    {
-      return *reinterpret_cast<VkConformanceVersionKHR*>(this);
-    }
-
-    bool operator==( ConformanceVersionKHR const& rhs ) const
-    {
-      return ( major == rhs.major )
-          && ( minor == rhs.minor )
-          && ( subminor == rhs.subminor )
-          && ( patch == rhs.patch );
-    }
-
-    bool operator!=( ConformanceVersionKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint8_t major;
-    uint8_t minor;
-    uint8_t subminor;
-    uint8_t patch;
-  };
-  static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
-
-  struct RectLayerKHR
-  {
-    RectLayerKHR( Offset2D offset_ = Offset2D(),
-                  Extent2D extent_ = Extent2D(),
-                  uint32_t layer_ = 0 )
-      : offset( offset_ )
-      , extent( extent_ )
-      , layer( layer_ )
-    {
-    }
-
-    explicit RectLayerKHR( Rect2D const& rect2D,
-                           uint32_t layer_ = 0 )
-      : offset( rect2D.offset )
-      , extent( rect2D.extent )
-      , layer( layer_ )
-    {}
-
-    RectLayerKHR( VkRectLayerKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
-    }
-
-    RectLayerKHR& operator=( VkRectLayerKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
-      return *this;
-    }
-    RectLayerKHR& setOffset( Offset2D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    RectLayerKHR& setExtent( Extent2D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    RectLayerKHR& setLayer( uint32_t layer_ )
-    {
-      layer = layer_;
-      return *this;
-    }
-
-    operator VkRectLayerKHR const&() const
-    {
-      return *reinterpret_cast<const VkRectLayerKHR*>(this);
-    }
-
-    operator VkRectLayerKHR &()
-    {
-      return *reinterpret_cast<VkRectLayerKHR*>(this);
-    }
-
-    bool operator==( RectLayerKHR const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( extent == rhs.extent )
-          && ( layer == rhs.layer );
-    }
-
-    bool operator!=( RectLayerKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Offset2D offset;
-    Extent2D extent;
-    uint32_t layer;
-  };
-  static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" );
-
-  struct PresentRegionKHR
-  {
-    PresentRegionKHR( uint32_t rectangleCount_ = 0,
-                      const RectLayerKHR* pRectangles_ = nullptr )
-      : rectangleCount( rectangleCount_ )
-      , pRectangles( pRectangles_ )
-    {
-    }
-
-    PresentRegionKHR( VkPresentRegionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
-    }
-
-    PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
-      return *this;
-    }
-    PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ )
-    {
-      rectangleCount = rectangleCount_;
-      return *this;
-    }
-
-    PresentRegionKHR& setPRectangles( const RectLayerKHR* pRectangles_ )
-    {
-      pRectangles = pRectangles_;
-      return *this;
-    }
-
-    operator VkPresentRegionKHR const&() const
-    {
-      return *reinterpret_cast<const VkPresentRegionKHR*>(this);
-    }
-
-    operator VkPresentRegionKHR &()
-    {
-      return *reinterpret_cast<VkPresentRegionKHR*>(this);
-    }
-
-    bool operator==( PresentRegionKHR const& rhs ) const
-    {
-      return ( rectangleCount == rhs.rectangleCount )
-          && ( pRectangles == rhs.pRectangles );
-    }
-
-    bool operator!=( PresentRegionKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t rectangleCount;
-    const RectLayerKHR* pRectangles;
-  };
-  static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
-
-  struct XYColorEXT
-  {
-    XYColorEXT( float x_ = 0,
-                float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    XYColorEXT( VkXYColorEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XYColorEXT ) );
-    }
-
-    XYColorEXT& operator=( VkXYColorEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XYColorEXT ) );
-      return *this;
-    }
-    XYColorEXT& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    XYColorEXT& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator VkXYColorEXT const&() const
-    {
-      return *reinterpret_cast<const VkXYColorEXT*>(this);
-    }
-
-    operator VkXYColorEXT &()
-    {
-      return *reinterpret_cast<VkXYColorEXT*>(this);
-    }
-
-    bool operator==( XYColorEXT const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( XYColorEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-  };
-  static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
-
-  struct RefreshCycleDurationGOOGLE
-  {
-    operator VkRefreshCycleDurationGOOGLE const&() const
-    {
-      return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>(this);
-    }
-
-    operator VkRefreshCycleDurationGOOGLE &()
-    {
-      return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this);
-    }
-
-    bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const
-    {
-      return ( refreshDuration == rhs.refreshDuration );
-    }
-
-    bool operator!=( RefreshCycleDurationGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint64_t refreshDuration;
-  };
-  static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
-
-  struct PastPresentationTimingGOOGLE
-  {
-    operator VkPastPresentationTimingGOOGLE const&() const
-    {
-      return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>(this);
-    }
-
-    operator VkPastPresentationTimingGOOGLE &()
-    {
-      return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this);
-    }
-
-    bool operator==( PastPresentationTimingGOOGLE const& rhs ) const
-    {
-      return ( presentID == rhs.presentID )
-          && ( desiredPresentTime == rhs.desiredPresentTime )
-          && ( actualPresentTime == rhs.actualPresentTime )
-          && ( earliestPresentTime == rhs.earliestPresentTime )
-          && ( presentMargin == rhs.presentMargin );
-    }
-
-    bool operator!=( PastPresentationTimingGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t presentID;
-    uint64_t desiredPresentTime;
-    uint64_t actualPresentTime;
-    uint64_t earliestPresentTime;
-    uint64_t presentMargin;
-  };
-  static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
-
-  struct PresentTimeGOOGLE
-  {
-    PresentTimeGOOGLE( uint32_t presentID_ = 0,
-                       uint64_t desiredPresentTime_ = 0 )
-      : presentID( presentID_ )
-      , desiredPresentTime( desiredPresentTime_ )
-    {
-    }
-
-    PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
-    }
-
-    PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
-      return *this;
-    }
-    PresentTimeGOOGLE& setPresentID( uint32_t presentID_ )
-    {
-      presentID = presentID_;
-      return *this;
-    }
-
-    PresentTimeGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ )
-    {
-      desiredPresentTime = desiredPresentTime_;
-      return *this;
-    }
-
-    operator VkPresentTimeGOOGLE const&() const
-    {
-      return *reinterpret_cast<const VkPresentTimeGOOGLE*>(this);
-    }
-
-    operator VkPresentTimeGOOGLE &()
-    {
-      return *reinterpret_cast<VkPresentTimeGOOGLE*>(this);
-    }
-
-    bool operator==( PresentTimeGOOGLE const& rhs ) const
-    {
-      return ( presentID == rhs.presentID )
-          && ( desiredPresentTime == rhs.desiredPresentTime );
-    }
-
-    bool operator!=( PresentTimeGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t presentID;
-    uint64_t desiredPresentTime;
-  };
-  static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
-
-  struct ViewportWScalingNV
-  {
-    ViewportWScalingNV( float xcoeff_ = 0,
-                        float ycoeff_ = 0 )
-      : xcoeff( xcoeff_ )
-      , ycoeff( ycoeff_ )
-    {
-    }
-
-    ViewportWScalingNV( VkViewportWScalingNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
-    }
-
-    ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
-      return *this;
-    }
-    ViewportWScalingNV& setXcoeff( float xcoeff_ )
-    {
-      xcoeff = xcoeff_;
-      return *this;
-    }
-
-    ViewportWScalingNV& setYcoeff( float ycoeff_ )
-    {
-      ycoeff = ycoeff_;
-      return *this;
-    }
-
-    operator VkViewportWScalingNV const&() const
-    {
-      return *reinterpret_cast<const VkViewportWScalingNV*>(this);
-    }
-
-    operator VkViewportWScalingNV &()
-    {
-      return *reinterpret_cast<VkViewportWScalingNV*>(this);
-    }
-
-    bool operator==( ViewportWScalingNV const& rhs ) const
-    {
-      return ( xcoeff == rhs.xcoeff )
-          && ( ycoeff == rhs.ycoeff );
-    }
-
-    bool operator!=( ViewportWScalingNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float xcoeff;
-    float ycoeff;
-  };
-  static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
-
-  struct SampleLocationEXT
-  {
-    SampleLocationEXT( float x_ = 0,
-                       float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    SampleLocationEXT( VkSampleLocationEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
-    }
-
-    SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
-      return *this;
-    }
-    SampleLocationEXT& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    SampleLocationEXT& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator VkSampleLocationEXT const&() const
-    {
-      return *reinterpret_cast<const VkSampleLocationEXT*>(this);
-    }
-
-    operator VkSampleLocationEXT &()
-    {
-      return *reinterpret_cast<VkSampleLocationEXT*>(this);
-    }
-
-    bool operator==( SampleLocationEXT const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( SampleLocationEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-  };
-  static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
-
-  struct ShaderResourceUsageAMD
-  {
-    operator VkShaderResourceUsageAMD const&() const
-    {
-      return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this);
-    }
-
-    operator VkShaderResourceUsageAMD &()
-    {
-      return *reinterpret_cast<VkShaderResourceUsageAMD*>(this);
-    }
-
-    bool operator==( ShaderResourceUsageAMD const& rhs ) const
-    {
-      return ( numUsedVgprs == rhs.numUsedVgprs )
-          && ( numUsedSgprs == rhs.numUsedSgprs )
-          && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup )
-          && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes )
-          && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes );
-    }
-
-    bool operator!=( ShaderResourceUsageAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t numUsedVgprs;
-    uint32_t numUsedSgprs;
-    uint32_t ldsSizePerLocalWorkGroup;
-    size_t ldsUsageSizeInBytes;
-    size_t scratchMemUsageInBytes;
-  };
-  static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" );
-
-  struct VertexInputBindingDivisorDescriptionEXT
-  {
-    VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0,
-                                             uint32_t divisor_ = 0 )
-      : binding( binding_ )
-      , divisor( divisor_ )
-    {
-    }
-
-    VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
-    }
-
-    VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
-      return *this;
-    }
-    VertexInputBindingDivisorDescriptionEXT& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputBindingDivisorDescriptionEXT& setDivisor( uint32_t divisor_ )
-    {
-      divisor = divisor_;
-      return *this;
-    }
-
-    operator VkVertexInputBindingDivisorDescriptionEXT const&() const
-    {
-      return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>(this);
-    }
-
-    operator VkVertexInputBindingDivisorDescriptionEXT &()
-    {
-      return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this);
-    }
-
-    bool operator==( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
-    {
-      return ( binding == rhs.binding )
-          && ( divisor == rhs.divisor );
-    }
-
-    bool operator!=( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t binding;
-    uint32_t divisor;
-  };
-  static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
-
-  struct CoarseSampleLocationNV
-  {
-    CoarseSampleLocationNV( uint32_t pixelX_ = 0,
-                            uint32_t pixelY_ = 0,
-                            uint32_t sample_ = 0 )
-      : pixelX( pixelX_ )
-      , pixelY( pixelY_ )
-      , sample( sample_ )
-    {
-    }
-
-    CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
-    }
-
-    CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
-      return *this;
-    }
-    CoarseSampleLocationNV& setPixelX( uint32_t pixelX_ )
-    {
-      pixelX = pixelX_;
-      return *this;
-    }
-
-    CoarseSampleLocationNV& setPixelY( uint32_t pixelY_ )
-    {
-      pixelY = pixelY_;
-      return *this;
-    }
-
-    CoarseSampleLocationNV& setSample( uint32_t sample_ )
-    {
-      sample = sample_;
-      return *this;
-    }
-
-    operator VkCoarseSampleLocationNV const&() const
-    {
-      return *reinterpret_cast<const VkCoarseSampleLocationNV*>(this);
-    }
-
-    operator VkCoarseSampleLocationNV &()
-    {
-      return *reinterpret_cast<VkCoarseSampleLocationNV*>(this);
-    }
-
-    bool operator==( CoarseSampleLocationNV const& rhs ) const
-    {
-      return ( pixelX == rhs.pixelX )
-          && ( pixelY == rhs.pixelY )
-          && ( sample == rhs.sample );
-    }
-
-    bool operator!=( CoarseSampleLocationNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t pixelX;
-    uint32_t pixelY;
-    uint32_t sample;
-  };
-  static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
-
-  struct DrawMeshTasksIndirectCommandNV
-  {
-    DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
-                                    uint32_t firstTask_ = 0 )
-      : taskCount( taskCount_ )
-      , firstTask( firstTask_ )
-    {
-    }
-
-    DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
-    }
-
-    DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
-      return *this;
-    }
-    DrawMeshTasksIndirectCommandNV& setTaskCount( uint32_t taskCount_ )
-    {
-      taskCount = taskCount_;
-      return *this;
-    }
-
-    DrawMeshTasksIndirectCommandNV& setFirstTask( uint32_t firstTask_ )
-    {
-      firstTask = firstTask_;
-      return *this;
-    }
-
-    operator VkDrawMeshTasksIndirectCommandNV const&() const
-    {
-      return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>(this);
-    }
-
-    operator VkDrawMeshTasksIndirectCommandNV &()
-    {
-      return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this);
-    }
-
-    bool operator==( DrawMeshTasksIndirectCommandNV const& rhs ) const
-    {
-      return ( taskCount == rhs.taskCount )
-          && ( firstTask == rhs.firstTask );
-    }
-
-    bool operator!=( DrawMeshTasksIndirectCommandNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t taskCount;
-    uint32_t firstTask;
-  };
-  static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
-
-  enum class ImageLayout
-  {
-    eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
-    eGeneral = VK_IMAGE_LAYOUT_GENERAL,
-    eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-    eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-    eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
-    eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-    eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-    eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-    ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
-    eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
-    eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
-    eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
-    eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
-    ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-    eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
-    eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV
-  };
-
-  struct DescriptorImageInfo
-  {
-    DescriptorImageInfo( Sampler sampler_ = Sampler(),
-                         ImageView imageView_ = ImageView(),
-                         ImageLayout imageLayout_ = ImageLayout::eUndefined )
-      : sampler( sampler_ )
-      , imageView( imageView_ )
-      , imageLayout( imageLayout_ )
-    {
-    }
-
-    DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
-    }
-
-    DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
-      return *this;
-    }
-    DescriptorImageInfo& setSampler( Sampler sampler_ )
-    {
-      sampler = sampler_;
-      return *this;
-    }
-
-    DescriptorImageInfo& setImageView( ImageView imageView_ )
-    {
-      imageView = imageView_;
-      return *this;
-    }
-
-    DescriptorImageInfo& setImageLayout( ImageLayout imageLayout_ )
-    {
-      imageLayout = imageLayout_;
-      return *this;
-    }
-
-    operator VkDescriptorImageInfo const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorImageInfo*>(this);
-    }
-
-    operator VkDescriptorImageInfo &()
-    {
-      return *reinterpret_cast<VkDescriptorImageInfo*>(this);
-    }
-
-    bool operator==( DescriptorImageInfo const& rhs ) const
-    {
-      return ( sampler == rhs.sampler )
-          && ( imageView == rhs.imageView )
-          && ( imageLayout == rhs.imageLayout );
-    }
-
-    bool operator!=( DescriptorImageInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Sampler sampler;
-    ImageView imageView;
-    ImageLayout imageLayout;
-  };
-  static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
-
-  struct AttachmentReference
-  {
-    AttachmentReference( uint32_t attachment_ = 0,
-                         ImageLayout layout_ = ImageLayout::eUndefined )
-      : attachment( attachment_ )
-      , layout( layout_ )
-    {
-    }
-
-    AttachmentReference( VkAttachmentReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference ) );
-    }
-
-    AttachmentReference& operator=( VkAttachmentReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference ) );
-      return *this;
-    }
-    AttachmentReference& setAttachment( uint32_t attachment_ )
-    {
-      attachment = attachment_;
-      return *this;
-    }
-
-    AttachmentReference& setLayout( ImageLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    operator VkAttachmentReference const&() const
-    {
-      return *reinterpret_cast<const VkAttachmentReference*>(this);
-    }
-
-    operator VkAttachmentReference &()
-    {
-      return *reinterpret_cast<VkAttachmentReference*>(this);
-    }
-
-    bool operator==( AttachmentReference const& rhs ) const
-    {
-      return ( attachment == rhs.attachment )
-          && ( layout == rhs.layout );
-    }
-
-    bool operator!=( AttachmentReference const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t attachment;
-    ImageLayout layout;
-  };
-  static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
+  }
 
   enum class AttachmentLoadOp
   {
@@ -8074,438 +2524,33 @@
     eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE
   };
 
+  VULKAN_HPP_INLINE std::string to_string( AttachmentLoadOp value )
+  {
+    switch ( value )
+    {
+      case AttachmentLoadOp::eLoad : return "Load";
+      case AttachmentLoadOp::eClear : return "Clear";
+      case AttachmentLoadOp::eDontCare : return "DontCare";
+      default: return "invalid";
+    }
+  }
+
   enum class AttachmentStoreOp
   {
     eStore = VK_ATTACHMENT_STORE_OP_STORE,
     eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE
   };
 
-  enum class ImageType
+  VULKAN_HPP_INLINE std::string to_string( AttachmentStoreOp value )
   {
-    e1D = VK_IMAGE_TYPE_1D,
-    e2D = VK_IMAGE_TYPE_2D,
-    e3D = VK_IMAGE_TYPE_3D
-  };
-
-  enum class ImageTiling
-  {
-    eOptimal = VK_IMAGE_TILING_OPTIMAL,
-    eLinear = VK_IMAGE_TILING_LINEAR,
-    eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
-  };
-
-  enum class ImageViewType
-  {
-    e1D = VK_IMAGE_VIEW_TYPE_1D,
-    e2D = VK_IMAGE_VIEW_TYPE_2D,
-    e3D = VK_IMAGE_VIEW_TYPE_3D,
-    eCube = VK_IMAGE_VIEW_TYPE_CUBE,
-    e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
-    e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
-    eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
-  };
-
-  enum class CommandBufferLevel
-  {
-    ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-    eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
-  };
-
-  enum class ComponentSwizzle
-  {
-    eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
-    eZero = VK_COMPONENT_SWIZZLE_ZERO,
-    eOne = VK_COMPONENT_SWIZZLE_ONE,
-    eR = VK_COMPONENT_SWIZZLE_R,
-    eG = VK_COMPONENT_SWIZZLE_G,
-    eB = VK_COMPONENT_SWIZZLE_B,
-    eA = VK_COMPONENT_SWIZZLE_A
-  };
-
-  struct ComponentMapping
-  {
-    ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle g_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle b_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle a_ = ComponentSwizzle::eIdentity )
-      : r( r_ )
-      , g( g_ )
-      , b( b_ )
-      , a( a_ )
+    switch ( value )
     {
+      case AttachmentStoreOp::eStore : return "Store";
+      case AttachmentStoreOp::eDontCare : return "DontCare";
+      default: return "invalid";
     }
-
-    ComponentMapping( VkComponentMapping const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComponentMapping ) );
-    }
-
-    ComponentMapping& operator=( VkComponentMapping const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComponentMapping ) );
-      return *this;
-    }
-    ComponentMapping& setR( ComponentSwizzle r_ )
-    {
-      r = r_;
-      return *this;
-    }
-
-    ComponentMapping& setG( ComponentSwizzle g_ )
-    {
-      g = g_;
-      return *this;
-    }
-
-    ComponentMapping& setB( ComponentSwizzle b_ )
-    {
-      b = b_;
-      return *this;
-    }
-
-    ComponentMapping& setA( ComponentSwizzle a_ )
-    {
-      a = a_;
-      return *this;
-    }
-
-    operator VkComponentMapping const&() const
-    {
-      return *reinterpret_cast<const VkComponentMapping*>(this);
-    }
-
-    operator VkComponentMapping &()
-    {
-      return *reinterpret_cast<VkComponentMapping*>(this);
-    }
-
-    bool operator==( ComponentMapping const& rhs ) const
-    {
-      return ( r == rhs.r )
-          && ( g == rhs.g )
-          && ( b == rhs.b )
-          && ( a == rhs.a );
-    }
-
-    bool operator!=( ComponentMapping const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ComponentSwizzle r;
-    ComponentSwizzle g;
-    ComponentSwizzle b;
-    ComponentSwizzle a;
-  };
-  static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
-
-  enum class DescriptorType
-  {
-    eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
-    eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-    eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-    eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-    eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
-    eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
-    eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-    eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-    eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-    eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
-    eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-    eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
-    eAccelerationStructureNVX = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX
-  };
-
-  struct DescriptorPoolSize
-  {
-    DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler,
-                        uint32_t descriptorCount_ = 0 )
-      : type( type_ )
-      , descriptorCount( descriptorCount_ )
-    {
-    }
-
-    DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
-    }
-
-    DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
-      return *this;
-    }
-    DescriptorPoolSize& setType( DescriptorType type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    DescriptorPoolSize& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    operator VkDescriptorPoolSize const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorPoolSize*>(this);
-    }
-
-    operator VkDescriptorPoolSize &()
-    {
-      return *reinterpret_cast<VkDescriptorPoolSize*>(this);
-    }
-
-    bool operator==( DescriptorPoolSize const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( descriptorCount == rhs.descriptorCount );
-    }
-
-    bool operator!=( DescriptorPoolSize const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DescriptorType type;
-    uint32_t descriptorCount;
-  };
-  static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
-
-  struct DescriptorUpdateTemplateEntry
-  {
-    DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0,
-                                   uint32_t dstArrayElement_ = 0,
-                                   uint32_t descriptorCount_ = 0,
-                                   DescriptorType descriptorType_ = DescriptorType::eSampler,
-                                   size_t offset_ = 0,
-                                   size_t stride_ = 0 )
-      : dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-      , descriptorType( descriptorType_ )
-      , offset( offset_ )
-      , stride( stride_ )
-    {
-    }
-
-    DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
-    }
-
-    DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
-      return *this;
-    }
-    DescriptorUpdateTemplateEntry& setDstBinding( uint32_t dstBinding_ )
-    {
-      dstBinding = dstBinding_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setDstArrayElement( uint32_t dstArrayElement_ )
-    {
-      dstArrayElement = dstArrayElement_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setDescriptorType( DescriptorType descriptorType_ )
-    {
-      descriptorType = descriptorType_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setOffset( size_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setStride( size_t stride_ )
-    {
-      stride = stride_;
-      return *this;
-    }
-
-    operator VkDescriptorUpdateTemplateEntry const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>(this);
-    }
-
-    operator VkDescriptorUpdateTemplateEntry &()
-    {
-      return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this);
-    }
-
-    bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const
-    {
-      return ( dstBinding == rhs.dstBinding )
-          && ( dstArrayElement == rhs.dstArrayElement )
-          && ( descriptorCount == rhs.descriptorCount )
-          && ( descriptorType == rhs.descriptorType )
-          && ( offset == rhs.offset )
-          && ( stride == rhs.stride );
-    }
-
-    bool operator!=( DescriptorUpdateTemplateEntry const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    DescriptorType descriptorType;
-    size_t offset;
-    size_t stride;
-  };
-  static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
-
-  using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
-
-  enum class QueryType
-  {
-    eOcclusion = VK_QUERY_TYPE_OCCLUSION,
-    ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
-    eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
-    eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
-    eCompactedSizeNVX = VK_QUERY_TYPE_COMPACTED_SIZE_NVX
-  };
-
-  enum class BorderColor
-  {
-    eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
-    eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
-    eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
-    eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
-    eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
-    eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
-  };
-
-  enum class PipelineBindPoint
-  {
-    eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
-    eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
-    eRaytracingNVX = VK_PIPELINE_BIND_POINT_RAYTRACING_NVX
-  };
-
-  enum class PipelineCacheHeaderVersion
-  {
-    eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
-  };
-
-  enum class PrimitiveTopology
-  {
-    ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
-    eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
-    eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
-    eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
-    eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
-    eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
-    eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
-    eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
-    eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
-    eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
-    ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
-  };
-
-  enum class SharingMode
-  {
-    eExclusive = VK_SHARING_MODE_EXCLUSIVE,
-    eConcurrent = VK_SHARING_MODE_CONCURRENT
-  };
-
-  enum class IndexType
-  {
-    eUint16 = VK_INDEX_TYPE_UINT16,
-    eUint32 = VK_INDEX_TYPE_UINT32
-  };
-
-  enum class Filter
-  {
-    eNearest = VK_FILTER_NEAREST,
-    eLinear = VK_FILTER_LINEAR,
-    eCubicIMG = VK_FILTER_CUBIC_IMG
-  };
-
-  enum class SamplerMipmapMode
-  {
-    eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
-    eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
-  };
-
-  enum class SamplerAddressMode
-  {
-    eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
-    eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
-    eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
-    eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-    eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
-  };
-
-  enum class CompareOp
-  {
-    eNever = VK_COMPARE_OP_NEVER,
-    eLess = VK_COMPARE_OP_LESS,
-    eEqual = VK_COMPARE_OP_EQUAL,
-    eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
-    eGreater = VK_COMPARE_OP_GREATER,
-    eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
-    eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
-    eAlways = VK_COMPARE_OP_ALWAYS
-  };
-
-  enum class PolygonMode
-  {
-    eFill = VK_POLYGON_MODE_FILL,
-    eLine = VK_POLYGON_MODE_LINE,
-    ePoint = VK_POLYGON_MODE_POINT,
-    eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV
-  };
-
-  enum class CullModeFlagBits
-  {
-    eNone = VK_CULL_MODE_NONE,
-    eFront = VK_CULL_MODE_FRONT_BIT,
-    eBack = VK_CULL_MODE_BACK_BIT,
-    eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK
-  };
-
-  using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>;
-
-  VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 )
-  {
-    return CullModeFlags( bit0 ) | bit1;
   }
 
-  VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits )
-  {
-    return ~( CullModeFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CullModeFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CullModeFlagBits::eNone) | VkFlags(CullModeFlagBits::eFront) | VkFlags(CullModeFlagBits::eBack) | VkFlags(CullModeFlagBits::eFrontAndBack)
-    };
-  };
-
-  enum class FrontFace
-  {
-    eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
-    eClockwise = VK_FRONT_FACE_CLOCKWISE
-  };
-
   enum class BlendFactor
   {
     eZero = VK_BLEND_FACTOR_ZERO,
@@ -8529,6 +2574,33 @@
     eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
   };
 
+  VULKAN_HPP_INLINE std::string to_string( BlendFactor value )
+  {
+    switch ( value )
+    {
+      case BlendFactor::eZero : return "Zero";
+      case BlendFactor::eOne : return "One";
+      case BlendFactor::eSrcColor : return "SrcColor";
+      case BlendFactor::eOneMinusSrcColor : return "OneMinusSrcColor";
+      case BlendFactor::eDstColor : return "DstColor";
+      case BlendFactor::eOneMinusDstColor : return "OneMinusDstColor";
+      case BlendFactor::eSrcAlpha : return "SrcAlpha";
+      case BlendFactor::eOneMinusSrcAlpha : return "OneMinusSrcAlpha";
+      case BlendFactor::eDstAlpha : return "DstAlpha";
+      case BlendFactor::eOneMinusDstAlpha : return "OneMinusDstAlpha";
+      case BlendFactor::eConstantColor : return "ConstantColor";
+      case BlendFactor::eOneMinusConstantColor : return "OneMinusConstantColor";
+      case BlendFactor::eConstantAlpha : return "ConstantAlpha";
+      case BlendFactor::eOneMinusConstantAlpha : return "OneMinusConstantAlpha";
+      case BlendFactor::eSrcAlphaSaturate : return "SrcAlphaSaturate";
+      case BlendFactor::eSrc1Color : return "Src1Color";
+      case BlendFactor::eOneMinusSrc1Color : return "OneMinusSrc1Color";
+      case BlendFactor::eSrc1Alpha : return "Src1Alpha";
+      case BlendFactor::eOneMinusSrc1Alpha : return "OneMinusSrc1Alpha";
+      default: return "invalid";
+    }
+  }
+
   enum class BlendOp
   {
     eAdd = VK_BLEND_OP_ADD,
@@ -8584,240 +2656,645 @@
     eBlueEXT = VK_BLEND_OP_BLUE_EXT
   };
 
-  enum class StencilOp
+  VULKAN_HPP_INLINE std::string to_string( BlendOp value )
   {
-    eKeep = VK_STENCIL_OP_KEEP,
-    eZero = VK_STENCIL_OP_ZERO,
-    eReplace = VK_STENCIL_OP_REPLACE,
-    eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
-    eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
-    eInvert = VK_STENCIL_OP_INVERT,
-    eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
-    eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
+    switch ( value )
+    {
+      case BlendOp::eAdd : return "Add";
+      case BlendOp::eSubtract : return "Subtract";
+      case BlendOp::eReverseSubtract : return "ReverseSubtract";
+      case BlendOp::eMin : return "Min";
+      case BlendOp::eMax : return "Max";
+      case BlendOp::eZeroEXT : return "ZeroEXT";
+      case BlendOp::eSrcEXT : return "SrcEXT";
+      case BlendOp::eDstEXT : return "DstEXT";
+      case BlendOp::eSrcOverEXT : return "SrcOverEXT";
+      case BlendOp::eDstOverEXT : return "DstOverEXT";
+      case BlendOp::eSrcInEXT : return "SrcInEXT";
+      case BlendOp::eDstInEXT : return "DstInEXT";
+      case BlendOp::eSrcOutEXT : return "SrcOutEXT";
+      case BlendOp::eDstOutEXT : return "DstOutEXT";
+      case BlendOp::eSrcAtopEXT : return "SrcAtopEXT";
+      case BlendOp::eDstAtopEXT : return "DstAtopEXT";
+      case BlendOp::eXorEXT : return "XorEXT";
+      case BlendOp::eMultiplyEXT : return "MultiplyEXT";
+      case BlendOp::eScreenEXT : return "ScreenEXT";
+      case BlendOp::eOverlayEXT : return "OverlayEXT";
+      case BlendOp::eDarkenEXT : return "DarkenEXT";
+      case BlendOp::eLightenEXT : return "LightenEXT";
+      case BlendOp::eColordodgeEXT : return "ColordodgeEXT";
+      case BlendOp::eColorburnEXT : return "ColorburnEXT";
+      case BlendOp::eHardlightEXT : return "HardlightEXT";
+      case BlendOp::eSoftlightEXT : return "SoftlightEXT";
+      case BlendOp::eDifferenceEXT : return "DifferenceEXT";
+      case BlendOp::eExclusionEXT : return "ExclusionEXT";
+      case BlendOp::eInvertEXT : return "InvertEXT";
+      case BlendOp::eInvertRgbEXT : return "InvertRgbEXT";
+      case BlendOp::eLineardodgeEXT : return "LineardodgeEXT";
+      case BlendOp::eLinearburnEXT : return "LinearburnEXT";
+      case BlendOp::eVividlightEXT : return "VividlightEXT";
+      case BlendOp::eLinearlightEXT : return "LinearlightEXT";
+      case BlendOp::ePinlightEXT : return "PinlightEXT";
+      case BlendOp::eHardmixEXT : return "HardmixEXT";
+      case BlendOp::eHslHueEXT : return "HslHueEXT";
+      case BlendOp::eHslSaturationEXT : return "HslSaturationEXT";
+      case BlendOp::eHslColorEXT : return "HslColorEXT";
+      case BlendOp::eHslLuminosityEXT : return "HslLuminosityEXT";
+      case BlendOp::ePlusEXT : return "PlusEXT";
+      case BlendOp::ePlusClampedEXT : return "PlusClampedEXT";
+      case BlendOp::ePlusClampedAlphaEXT : return "PlusClampedAlphaEXT";
+      case BlendOp::ePlusDarkerEXT : return "PlusDarkerEXT";
+      case BlendOp::eMinusEXT : return "MinusEXT";
+      case BlendOp::eMinusClampedEXT : return "MinusClampedEXT";
+      case BlendOp::eContrastEXT : return "ContrastEXT";
+      case BlendOp::eInvertOvgEXT : return "InvertOvgEXT";
+      case BlendOp::eRedEXT : return "RedEXT";
+      case BlendOp::eGreenEXT : return "GreenEXT";
+      case BlendOp::eBlueEXT : return "BlueEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class BlendOverlapEXT
+  {
+    eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
+    eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
+    eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
   };
 
-  struct StencilOpState
+  VULKAN_HPP_INLINE std::string to_string( BlendOverlapEXT value )
   {
-    StencilOpState( StencilOp failOp_ = StencilOp::eKeep,
-                    StencilOp passOp_ = StencilOp::eKeep,
-                    StencilOp depthFailOp_ = StencilOp::eKeep,
-                    CompareOp compareOp_ = CompareOp::eNever,
-                    uint32_t compareMask_ = 0,
-                    uint32_t writeMask_ = 0,
-                    uint32_t reference_ = 0 )
-      : failOp( failOp_ )
-      , passOp( passOp_ )
-      , depthFailOp( depthFailOp_ )
-      , compareOp( compareOp_ )
-      , compareMask( compareMask_ )
-      , writeMask( writeMask_ )
-      , reference( reference_ )
+    switch ( value )
     {
+      case BlendOverlapEXT::eUncorrelated : return "Uncorrelated";
+      case BlendOverlapEXT::eDisjoint : return "Disjoint";
+      case BlendOverlapEXT::eConjoint : return "Conjoint";
+      default: return "invalid";
     }
+  }
 
-    StencilOpState( VkStencilOpState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( StencilOpState ) );
-    }
-
-    StencilOpState& operator=( VkStencilOpState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( StencilOpState ) );
-      return *this;
-    }
-    StencilOpState& setFailOp( StencilOp failOp_ )
-    {
-      failOp = failOp_;
-      return *this;
-    }
-
-    StencilOpState& setPassOp( StencilOp passOp_ )
-    {
-      passOp = passOp_;
-      return *this;
-    }
-
-    StencilOpState& setDepthFailOp( StencilOp depthFailOp_ )
-    {
-      depthFailOp = depthFailOp_;
-      return *this;
-    }
-
-    StencilOpState& setCompareOp( CompareOp compareOp_ )
-    {
-      compareOp = compareOp_;
-      return *this;
-    }
-
-    StencilOpState& setCompareMask( uint32_t compareMask_ )
-    {
-      compareMask = compareMask_;
-      return *this;
-    }
-
-    StencilOpState& setWriteMask( uint32_t writeMask_ )
-    {
-      writeMask = writeMask_;
-      return *this;
-    }
-
-    StencilOpState& setReference( uint32_t reference_ )
-    {
-      reference = reference_;
-      return *this;
-    }
-
-    operator VkStencilOpState const&() const
-    {
-      return *reinterpret_cast<const VkStencilOpState*>(this);
-    }
-
-    operator VkStencilOpState &()
-    {
-      return *reinterpret_cast<VkStencilOpState*>(this);
-    }
-
-    bool operator==( StencilOpState const& rhs ) const
-    {
-      return ( failOp == rhs.failOp )
-          && ( passOp == rhs.passOp )
-          && ( depthFailOp == rhs.depthFailOp )
-          && ( compareOp == rhs.compareOp )
-          && ( compareMask == rhs.compareMask )
-          && ( writeMask == rhs.writeMask )
-          && ( reference == rhs.reference );
-    }
-
-    bool operator!=( StencilOpState const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    StencilOp failOp;
-    StencilOp passOp;
-    StencilOp depthFailOp;
-    CompareOp compareOp;
-    uint32_t compareMask;
-    uint32_t writeMask;
-    uint32_t reference;
-  };
-  static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
-
-  enum class LogicOp
+  enum class BorderColor
   {
-    eClear = VK_LOGIC_OP_CLEAR,
-    eAnd = VK_LOGIC_OP_AND,
-    eAndReverse = VK_LOGIC_OP_AND_REVERSE,
-    eCopy = VK_LOGIC_OP_COPY,
-    eAndInverted = VK_LOGIC_OP_AND_INVERTED,
-    eNoOp = VK_LOGIC_OP_NO_OP,
-    eXor = VK_LOGIC_OP_XOR,
-    eOr = VK_LOGIC_OP_OR,
-    eNor = VK_LOGIC_OP_NOR,
-    eEquivalent = VK_LOGIC_OP_EQUIVALENT,
-    eInvert = VK_LOGIC_OP_INVERT,
-    eOrReverse = VK_LOGIC_OP_OR_REVERSE,
-    eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
-    eOrInverted = VK_LOGIC_OP_OR_INVERTED,
-    eNand = VK_LOGIC_OP_NAND,
-    eSet = VK_LOGIC_OP_SET
+    eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+    eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
+    eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
+    eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
+    eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
+    eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
   };
 
-  enum class InternalAllocationType
+  VULKAN_HPP_INLINE std::string to_string( BorderColor value )
   {
-    eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
+    switch ( value )
+    {
+      case BorderColor::eFloatTransparentBlack : return "FloatTransparentBlack";
+      case BorderColor::eIntTransparentBlack : return "IntTransparentBlack";
+      case BorderColor::eFloatOpaqueBlack : return "FloatOpaqueBlack";
+      case BorderColor::eIntOpaqueBlack : return "IntOpaqueBlack";
+      case BorderColor::eFloatOpaqueWhite : return "FloatOpaqueWhite";
+      case BorderColor::eIntOpaqueWhite : return "IntOpaqueWhite";
+      default: return "invalid";
+    }
+  }
+
+  enum class ChromaLocation
+  {
+    eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN,
+    eMidpoint = VK_CHROMA_LOCATION_MIDPOINT,
+    eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN_KHR,
+    eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT_KHR
   };
 
-  enum class SystemAllocationScope
+  VULKAN_HPP_INLINE std::string to_string( ChromaLocation value )
   {
-    eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
-    eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
-    eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
-    eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
-    eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+    switch ( value )
+    {
+      case ChromaLocation::eCositedEven : return "CositedEven";
+      case ChromaLocation::eMidpoint : return "Midpoint";
+      default: return "invalid";
+    }
+  }
+
+  enum class CoarseSampleOrderTypeNV
+  {
+    eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
+    eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV,
+    ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV,
+    eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
   };
 
-  enum class PhysicalDeviceType
+  VULKAN_HPP_INLINE std::string to_string( CoarseSampleOrderTypeNV value )
   {
-    eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
-    eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
-    eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
-    eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
-    eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
+    switch ( value )
+    {
+      case CoarseSampleOrderTypeNV::eDefault : return "Default";
+      case CoarseSampleOrderTypeNV::eCustom : return "Custom";
+      case CoarseSampleOrderTypeNV::ePixelMajor : return "PixelMajor";
+      case CoarseSampleOrderTypeNV::eSampleMajor : return "SampleMajor";
+      default: return "invalid";
+    }
+  }
+
+  enum class ColorSpaceKHR
+  {
+    eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
+    eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
+    eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
+    eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
+    eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
+    eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
+    eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
+    eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
+    eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
+    eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
+    eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
+    eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
+    ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
+    eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT,
+    eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR
   };
 
-  enum class VertexInputRate
+  VULKAN_HPP_INLINE std::string to_string( ColorSpaceKHR value )
   {
-    eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
-    eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
+    switch ( value )
+    {
+      case ColorSpaceKHR::eSrgbNonlinear : return "SrgbNonlinear";
+      case ColorSpaceKHR::eDisplayP3NonlinearEXT : return "DisplayP3NonlinearEXT";
+      case ColorSpaceKHR::eExtendedSrgbLinearEXT : return "ExtendedSrgbLinearEXT";
+      case ColorSpaceKHR::eDciP3LinearEXT : return "DciP3LinearEXT";
+      case ColorSpaceKHR::eDciP3NonlinearEXT : return "DciP3NonlinearEXT";
+      case ColorSpaceKHR::eBt709LinearEXT : return "Bt709LinearEXT";
+      case ColorSpaceKHR::eBt709NonlinearEXT : return "Bt709NonlinearEXT";
+      case ColorSpaceKHR::eBt2020LinearEXT : return "Bt2020LinearEXT";
+      case ColorSpaceKHR::eHdr10St2084EXT : return "Hdr10St2084EXT";
+      case ColorSpaceKHR::eDolbyvisionEXT : return "DolbyvisionEXT";
+      case ColorSpaceKHR::eHdr10HlgEXT : return "Hdr10HlgEXT";
+      case ColorSpaceKHR::eAdobergbLinearEXT : return "AdobergbLinearEXT";
+      case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT";
+      case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT";
+      case ColorSpaceKHR::eExtendedSrgbNonlinearEXT : return "ExtendedSrgbNonlinearEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class CommandBufferLevel
+  {
+    ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
   };
 
-  struct VertexInputBindingDescription
+  VULKAN_HPP_INLINE std::string to_string( CommandBufferLevel value )
   {
-    VertexInputBindingDescription( uint32_t binding_ = 0,
-                                   uint32_t stride_ = 0,
-                                   VertexInputRate inputRate_ = VertexInputRate::eVertex )
-      : binding( binding_ )
-      , stride( stride_ )
-      , inputRate( inputRate_ )
+    switch ( value )
     {
+      case CommandBufferLevel::ePrimary : return "Primary";
+      case CommandBufferLevel::eSecondary : return "Secondary";
+      default: return "invalid";
     }
+  }
 
-    VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
-    }
-
-    VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
-      return *this;
-    }
-    VertexInputBindingDescription& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputBindingDescription& setStride( uint32_t stride_ )
-    {
-      stride = stride_;
-      return *this;
-    }
-
-    VertexInputBindingDescription& setInputRate( VertexInputRate inputRate_ )
-    {
-      inputRate = inputRate_;
-      return *this;
-    }
-
-    operator VkVertexInputBindingDescription const&() const
-    {
-      return *reinterpret_cast<const VkVertexInputBindingDescription*>(this);
-    }
-
-    operator VkVertexInputBindingDescription &()
-    {
-      return *reinterpret_cast<VkVertexInputBindingDescription*>(this);
-    }
-
-    bool operator==( VertexInputBindingDescription const& rhs ) const
-    {
-      return ( binding == rhs.binding )
-          && ( stride == rhs.stride )
-          && ( inputRate == rhs.inputRate );
-    }
-
-    bool operator!=( VertexInputBindingDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t binding;
-    uint32_t stride;
-    VertexInputRate inputRate;
+  enum class CompareOp
+  {
+    eNever = VK_COMPARE_OP_NEVER,
+    eLess = VK_COMPARE_OP_LESS,
+    eEqual = VK_COMPARE_OP_EQUAL,
+    eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
+    eGreater = VK_COMPARE_OP_GREATER,
+    eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
+    eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
+    eAlways = VK_COMPARE_OP_ALWAYS
   };
-  static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
+
+  VULKAN_HPP_INLINE std::string to_string( CompareOp value )
+  {
+    switch ( value )
+    {
+      case CompareOp::eNever : return "Never";
+      case CompareOp::eLess : return "Less";
+      case CompareOp::eEqual : return "Equal";
+      case CompareOp::eLessOrEqual : return "LessOrEqual";
+      case CompareOp::eGreater : return "Greater";
+      case CompareOp::eNotEqual : return "NotEqual";
+      case CompareOp::eGreaterOrEqual : return "GreaterOrEqual";
+      case CompareOp::eAlways : return "Always";
+      default: return "invalid";
+    }
+  }
+
+  enum class ComponentSwizzle
+  {
+    eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
+    eZero = VK_COMPONENT_SWIZZLE_ZERO,
+    eOne = VK_COMPONENT_SWIZZLE_ONE,
+    eR = VK_COMPONENT_SWIZZLE_R,
+    eG = VK_COMPONENT_SWIZZLE_G,
+    eB = VK_COMPONENT_SWIZZLE_B,
+    eA = VK_COMPONENT_SWIZZLE_A
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ComponentSwizzle value )
+  {
+    switch ( value )
+    {
+      case ComponentSwizzle::eIdentity : return "Identity";
+      case ComponentSwizzle::eZero : return "Zero";
+      case ComponentSwizzle::eOne : return "One";
+      case ComponentSwizzle::eR : return "R";
+      case ComponentSwizzle::eG : return "G";
+      case ComponentSwizzle::eB : return "B";
+      case ComponentSwizzle::eA : return "A";
+      default: return "invalid";
+    }
+  }
+
+  enum class ComponentTypeNV
+  {
+    eFloat16 = VK_COMPONENT_TYPE_FLOAT16_NV,
+    eFloat32 = VK_COMPONENT_TYPE_FLOAT32_NV,
+    eFloat64 = VK_COMPONENT_TYPE_FLOAT64_NV,
+    eSint8 = VK_COMPONENT_TYPE_SINT8_NV,
+    eSint16 = VK_COMPONENT_TYPE_SINT16_NV,
+    eSint32 = VK_COMPONENT_TYPE_SINT32_NV,
+    eSint64 = VK_COMPONENT_TYPE_SINT64_NV,
+    eUint8 = VK_COMPONENT_TYPE_UINT8_NV,
+    eUint16 = VK_COMPONENT_TYPE_UINT16_NV,
+    eUint32 = VK_COMPONENT_TYPE_UINT32_NV,
+    eUint64 = VK_COMPONENT_TYPE_UINT64_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ComponentTypeNV value )
+  {
+    switch ( value )
+    {
+      case ComponentTypeNV::eFloat16 : return "Float16";
+      case ComponentTypeNV::eFloat32 : return "Float32";
+      case ComponentTypeNV::eFloat64 : return "Float64";
+      case ComponentTypeNV::eSint8 : return "Sint8";
+      case ComponentTypeNV::eSint16 : return "Sint16";
+      case ComponentTypeNV::eSint32 : return "Sint32";
+      case ComponentTypeNV::eSint64 : return "Sint64";
+      case ComponentTypeNV::eUint8 : return "Uint8";
+      case ComponentTypeNV::eUint16 : return "Uint16";
+      case ComponentTypeNV::eUint32 : return "Uint32";
+      case ComponentTypeNV::eUint64 : return "Uint64";
+      default: return "invalid";
+    }
+  }
+
+  enum class ConservativeRasterizationModeEXT
+  {
+    eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
+    eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
+    eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ConservativeRasterizationModeEXT value )
+  {
+    switch ( value )
+    {
+      case ConservativeRasterizationModeEXT::eDisabled : return "Disabled";
+      case ConservativeRasterizationModeEXT::eOverestimate : return "Overestimate";
+      case ConservativeRasterizationModeEXT::eUnderestimate : return "Underestimate";
+      default: return "invalid";
+    }
+  }
+
+  enum class CopyAccelerationStructureModeNV
+  {
+    eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV,
+    eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CopyAccelerationStructureModeNV value )
+  {
+    switch ( value )
+    {
+      case CopyAccelerationStructureModeNV::eClone : return "Clone";
+      case CopyAccelerationStructureModeNV::eCompact : return "Compact";
+      default: return "invalid";
+    }
+  }
+
+  enum class CoverageModulationModeNV
+  {
+    eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
+    eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
+    eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
+    eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CoverageModulationModeNV value )
+  {
+    switch ( value )
+    {
+      case CoverageModulationModeNV::eNone : return "None";
+      case CoverageModulationModeNV::eRgb : return "Rgb";
+      case CoverageModulationModeNV::eAlpha : return "Alpha";
+      case CoverageModulationModeNV::eRgba : return "Rgba";
+      default: return "invalid";
+    }
+  }
+
+  enum class DebugReportObjectTypeEXT
+  {
+    eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+    eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
+    ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+    eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+    eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
+    eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
+    eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+    eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
+    eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
+    eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+    eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+    eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
+    eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
+    eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
+    eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+    eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
+    ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
+    ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
+    eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+    ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+    eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
+    eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
+    eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
+    eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+    eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
+    eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
+    eSurfaceKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
+    eSwapchainKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+    eDebugReportCallbackEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
+    eDisplayKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
+    eDisplayModeKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
+    eObjectTableNVX = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
+    eIndirectCommandsLayoutNVX = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
+    eValidationCacheEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
+    eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
+    eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+    eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+    eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT,
+    eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT,
+    eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT,
+    eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugReportObjectTypeEXT value )
+  {
+    switch ( value )
+    {
+      case DebugReportObjectTypeEXT::eUnknown : return "Unknown";
+      case DebugReportObjectTypeEXT::eInstance : return "Instance";
+      case DebugReportObjectTypeEXT::ePhysicalDevice : return "PhysicalDevice";
+      case DebugReportObjectTypeEXT::eDevice : return "Device";
+      case DebugReportObjectTypeEXT::eQueue : return "Queue";
+      case DebugReportObjectTypeEXT::eSemaphore : return "Semaphore";
+      case DebugReportObjectTypeEXT::eCommandBuffer : return "CommandBuffer";
+      case DebugReportObjectTypeEXT::eFence : return "Fence";
+      case DebugReportObjectTypeEXT::eDeviceMemory : return "DeviceMemory";
+      case DebugReportObjectTypeEXT::eBuffer : return "Buffer";
+      case DebugReportObjectTypeEXT::eImage : return "Image";
+      case DebugReportObjectTypeEXT::eEvent : return "Event";
+      case DebugReportObjectTypeEXT::eQueryPool : return "QueryPool";
+      case DebugReportObjectTypeEXT::eBufferView : return "BufferView";
+      case DebugReportObjectTypeEXT::eImageView : return "ImageView";
+      case DebugReportObjectTypeEXT::eShaderModule : return "ShaderModule";
+      case DebugReportObjectTypeEXT::ePipelineCache : return "PipelineCache";
+      case DebugReportObjectTypeEXT::ePipelineLayout : return "PipelineLayout";
+      case DebugReportObjectTypeEXT::eRenderPass : return "RenderPass";
+      case DebugReportObjectTypeEXT::ePipeline : return "Pipeline";
+      case DebugReportObjectTypeEXT::eDescriptorSetLayout : return "DescriptorSetLayout";
+      case DebugReportObjectTypeEXT::eSampler : return "Sampler";
+      case DebugReportObjectTypeEXT::eDescriptorPool : return "DescriptorPool";
+      case DebugReportObjectTypeEXT::eDescriptorSet : return "DescriptorSet";
+      case DebugReportObjectTypeEXT::eFramebuffer : return "Framebuffer";
+      case DebugReportObjectTypeEXT::eCommandPool : return "CommandPool";
+      case DebugReportObjectTypeEXT::eSurfaceKHR : return "SurfaceKHR";
+      case DebugReportObjectTypeEXT::eSwapchainKHR : return "SwapchainKHR";
+      case DebugReportObjectTypeEXT::eDebugReportCallbackEXT : return "DebugReportCallbackEXT";
+      case DebugReportObjectTypeEXT::eDisplayKHR : return "DisplayKHR";
+      case DebugReportObjectTypeEXT::eDisplayModeKHR : return "DisplayModeKHR";
+      case DebugReportObjectTypeEXT::eObjectTableNVX : return "ObjectTableNVX";
+      case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNVX : return "IndirectCommandsLayoutNVX";
+      case DebugReportObjectTypeEXT::eValidationCacheEXT : return "ValidationCacheEXT";
+      case DebugReportObjectTypeEXT::eSamplerYcbcrConversion : return "SamplerYcbcrConversion";
+      case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate : return "DescriptorUpdateTemplate";
+      case DebugReportObjectTypeEXT::eAccelerationStructureNV : return "AccelerationStructureNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class DescriptorType
+  {
+    eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
+    eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+    eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+    eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+    eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
+    eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
+    eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+    eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+    eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+    eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
+    eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+    eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
+    eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorType value )
+  {
+    switch ( value )
+    {
+      case DescriptorType::eSampler : return "Sampler";
+      case DescriptorType::eCombinedImageSampler : return "CombinedImageSampler";
+      case DescriptorType::eSampledImage : return "SampledImage";
+      case DescriptorType::eStorageImage : return "StorageImage";
+      case DescriptorType::eUniformTexelBuffer : return "UniformTexelBuffer";
+      case DescriptorType::eStorageTexelBuffer : return "StorageTexelBuffer";
+      case DescriptorType::eUniformBuffer : return "UniformBuffer";
+      case DescriptorType::eStorageBuffer : return "StorageBuffer";
+      case DescriptorType::eUniformBufferDynamic : return "UniformBufferDynamic";
+      case DescriptorType::eStorageBufferDynamic : return "StorageBufferDynamic";
+      case DescriptorType::eInputAttachment : return "InputAttachment";
+      case DescriptorType::eInlineUniformBlockEXT : return "InlineUniformBlockEXT";
+      case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class DescriptorUpdateTemplateType
+  {
+    eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
+    eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateType value )
+  {
+    switch ( value )
+    {
+      case DescriptorUpdateTemplateType::eDescriptorSet : return "DescriptorSet";
+      case DescriptorUpdateTemplateType::ePushDescriptorsKHR : return "PushDescriptorsKHR";
+      default: return "invalid";
+    }
+  }
+
+  enum class DeviceEventTypeEXT
+  {
+    eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceEventTypeEXT value )
+  {
+    switch ( value )
+    {
+      case DeviceEventTypeEXT::eDisplayHotplug : return "DisplayHotplug";
+      default: return "invalid";
+    }
+  }
+
+  enum class DiscardRectangleModeEXT
+  {
+    eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
+    eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DiscardRectangleModeEXT value )
+  {
+    switch ( value )
+    {
+      case DiscardRectangleModeEXT::eInclusive : return "Inclusive";
+      case DiscardRectangleModeEXT::eExclusive : return "Exclusive";
+      default: return "invalid";
+    }
+  }
+
+  enum class DisplayEventTypeEXT
+  {
+    eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayEventTypeEXT value )
+  {
+    switch ( value )
+    {
+      case DisplayEventTypeEXT::eFirstPixelOut : return "FirstPixelOut";
+      default: return "invalid";
+    }
+  }
+
+  enum class DisplayPowerStateEXT
+  {
+    eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
+    eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
+    eOn = VK_DISPLAY_POWER_STATE_ON_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayPowerStateEXT value )
+  {
+    switch ( value )
+    {
+      case DisplayPowerStateEXT::eOff : return "Off";
+      case DisplayPowerStateEXT::eSuspend : return "Suspend";
+      case DisplayPowerStateEXT::eOn : return "On";
+      default: return "invalid";
+    }
+  }
+
+  enum class DriverIdKHR
+  {
+    eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY_KHR,
+    eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR,
+    eMesaRadv = VK_DRIVER_ID_MESA_RADV_KHR,
+    eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR,
+    eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR,
+    eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR,
+    eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR,
+    eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR,
+    eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR,
+    eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DriverIdKHR value )
+  {
+    switch ( value )
+    {
+      case DriverIdKHR::eAmdProprietary : return "AmdProprietary";
+      case DriverIdKHR::eAmdOpenSource : return "AmdOpenSource";
+      case DriverIdKHR::eMesaRadv : return "MesaRadv";
+      case DriverIdKHR::eNvidiaProprietary : return "NvidiaProprietary";
+      case DriverIdKHR::eIntelProprietaryWindows : return "IntelProprietaryWindows";
+      case DriverIdKHR::eIntelOpenSourceMESA : return "IntelOpenSourceMESA";
+      case DriverIdKHR::eImaginationProprietary : return "ImaginationProprietary";
+      case DriverIdKHR::eQualcommProprietary : return "QualcommProprietary";
+      case DriverIdKHR::eArmProprietary : return "ArmProprietary";
+      case DriverIdKHR::eGooglePastel : return "GooglePastel";
+      default: return "invalid";
+    }
+  }
+
+  enum class DynamicState
+  {
+    eViewport = VK_DYNAMIC_STATE_VIEWPORT,
+    eScissor = VK_DYNAMIC_STATE_SCISSOR,
+    eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
+    eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
+    eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+    eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
+    eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+    eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
+    eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+    eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
+    eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
+    eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
+    eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
+    eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
+    eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DynamicState value )
+  {
+    switch ( value )
+    {
+      case DynamicState::eViewport : return "Viewport";
+      case DynamicState::eScissor : return "Scissor";
+      case DynamicState::eLineWidth : return "LineWidth";
+      case DynamicState::eDepthBias : return "DepthBias";
+      case DynamicState::eBlendConstants : return "BlendConstants";
+      case DynamicState::eDepthBounds : return "DepthBounds";
+      case DynamicState::eStencilCompareMask : return "StencilCompareMask";
+      case DynamicState::eStencilWriteMask : return "StencilWriteMask";
+      case DynamicState::eStencilReference : return "StencilReference";
+      case DynamicState::eViewportWScalingNV : return "ViewportWScalingNV";
+      case DynamicState::eDiscardRectangleEXT : return "DiscardRectangleEXT";
+      case DynamicState::eSampleLocationsEXT : return "SampleLocationsEXT";
+      case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV";
+      case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV";
+      case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class Filter
+  {
+    eNearest = VK_FILTER_NEAREST,
+    eLinear = VK_FILTER_LINEAR,
+    eCubicIMG = VK_FILTER_CUBIC_IMG,
+    eCubicEXT = VK_FILTER_CUBIC_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( Filter value )
+  {
+    switch ( value )
+    {
+      case Filter::eNearest : return "Nearest";
+      case Filter::eLinear : return "Linear";
+      case Filter::eCubicIMG : return "CubicIMG";
+      default: return "invalid";
+    }
+  }
 
   enum class Format
   {
@@ -9007,73 +3484,39 @@
     eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
     eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
     eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM,
-    eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM,
     eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM,
-    eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM,
     eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
-    eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
     eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
-    eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
     eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
-    eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
     eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
-    eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
     eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
-    eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
     eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16,
-    eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16,
     eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
-    eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
     eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
-    eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
     eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
-    eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
     eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
-    eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
     eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
-    eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
     eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
-    eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
     eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
-    eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
     eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
-    eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
     eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
-    eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
     eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16,
-    eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16,
     eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
-    eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
     eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
-    eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
     eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
-    eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
     eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
-    eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
     eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
-    eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
     eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
-    eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
     eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
-    eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
     eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
-    eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
     eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
-    eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
     eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM,
-    eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM,
     eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM,
-    eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM,
     eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
-    eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
     eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
-    eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
     eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
-    eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
     eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
-    eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
     eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
-    eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
     ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
     ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
     ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
@@ -9081,85 +3524,1170 @@
     ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
     ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
     ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
-    ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG
+    ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
+    eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
+    eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
+    eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
+    eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
+    eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
+    eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
+    eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
+    eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR,
+    eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
+    eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
+    eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
+    eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
+    eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
+    eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR,
+    eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
+    eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
+    eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
+    eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
+    eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
+    eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
+    eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
+    eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
+    eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
+    eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
+    eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
+    eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR
   };
 
-  struct VertexInputAttributeDescription
+  VULKAN_HPP_INLINE std::string to_string( Format value )
   {
-    VertexInputAttributeDescription( uint32_t location_ = 0,
-                                     uint32_t binding_ = 0,
-                                     Format format_ = Format::eUndefined,
-                                     uint32_t offset_ = 0 )
-      : location( location_ )
-      , binding( binding_ )
-      , format( format_ )
-      , offset( offset_ )
+    switch ( value )
     {
+      case Format::eUndefined : return "Undefined";
+      case Format::eR4G4UnormPack8 : return "R4G4UnormPack8";
+      case Format::eR4G4B4A4UnormPack16 : return "R4G4B4A4UnormPack16";
+      case Format::eB4G4R4A4UnormPack16 : return "B4G4R4A4UnormPack16";
+      case Format::eR5G6B5UnormPack16 : return "R5G6B5UnormPack16";
+      case Format::eB5G6R5UnormPack16 : return "B5G6R5UnormPack16";
+      case Format::eR5G5B5A1UnormPack16 : return "R5G5B5A1UnormPack16";
+      case Format::eB5G5R5A1UnormPack16 : return "B5G5R5A1UnormPack16";
+      case Format::eA1R5G5B5UnormPack16 : return "A1R5G5B5UnormPack16";
+      case Format::eR8Unorm : return "R8Unorm";
+      case Format::eR8Snorm : return "R8Snorm";
+      case Format::eR8Uscaled : return "R8Uscaled";
+      case Format::eR8Sscaled : return "R8Sscaled";
+      case Format::eR8Uint : return "R8Uint";
+      case Format::eR8Sint : return "R8Sint";
+      case Format::eR8Srgb : return "R8Srgb";
+      case Format::eR8G8Unorm : return "R8G8Unorm";
+      case Format::eR8G8Snorm : return "R8G8Snorm";
+      case Format::eR8G8Uscaled : return "R8G8Uscaled";
+      case Format::eR8G8Sscaled : return "R8G8Sscaled";
+      case Format::eR8G8Uint : return "R8G8Uint";
+      case Format::eR8G8Sint : return "R8G8Sint";
+      case Format::eR8G8Srgb : return "R8G8Srgb";
+      case Format::eR8G8B8Unorm : return "R8G8B8Unorm";
+      case Format::eR8G8B8Snorm : return "R8G8B8Snorm";
+      case Format::eR8G8B8Uscaled : return "R8G8B8Uscaled";
+      case Format::eR8G8B8Sscaled : return "R8G8B8Sscaled";
+      case Format::eR8G8B8Uint : return "R8G8B8Uint";
+      case Format::eR8G8B8Sint : return "R8G8B8Sint";
+      case Format::eR8G8B8Srgb : return "R8G8B8Srgb";
+      case Format::eB8G8R8Unorm : return "B8G8R8Unorm";
+      case Format::eB8G8R8Snorm : return "B8G8R8Snorm";
+      case Format::eB8G8R8Uscaled : return "B8G8R8Uscaled";
+      case Format::eB8G8R8Sscaled : return "B8G8R8Sscaled";
+      case Format::eB8G8R8Uint : return "B8G8R8Uint";
+      case Format::eB8G8R8Sint : return "B8G8R8Sint";
+      case Format::eB8G8R8Srgb : return "B8G8R8Srgb";
+      case Format::eR8G8B8A8Unorm : return "R8G8B8A8Unorm";
+      case Format::eR8G8B8A8Snorm : return "R8G8B8A8Snorm";
+      case Format::eR8G8B8A8Uscaled : return "R8G8B8A8Uscaled";
+      case Format::eR8G8B8A8Sscaled : return "R8G8B8A8Sscaled";
+      case Format::eR8G8B8A8Uint : return "R8G8B8A8Uint";
+      case Format::eR8G8B8A8Sint : return "R8G8B8A8Sint";
+      case Format::eR8G8B8A8Srgb : return "R8G8B8A8Srgb";
+      case Format::eB8G8R8A8Unorm : return "B8G8R8A8Unorm";
+      case Format::eB8G8R8A8Snorm : return "B8G8R8A8Snorm";
+      case Format::eB8G8R8A8Uscaled : return "B8G8R8A8Uscaled";
+      case Format::eB8G8R8A8Sscaled : return "B8G8R8A8Sscaled";
+      case Format::eB8G8R8A8Uint : return "B8G8R8A8Uint";
+      case Format::eB8G8R8A8Sint : return "B8G8R8A8Sint";
+      case Format::eB8G8R8A8Srgb : return "B8G8R8A8Srgb";
+      case Format::eA8B8G8R8UnormPack32 : return "A8B8G8R8UnormPack32";
+      case Format::eA8B8G8R8SnormPack32 : return "A8B8G8R8SnormPack32";
+      case Format::eA8B8G8R8UscaledPack32 : return "A8B8G8R8UscaledPack32";
+      case Format::eA8B8G8R8SscaledPack32 : return "A8B8G8R8SscaledPack32";
+      case Format::eA8B8G8R8UintPack32 : return "A8B8G8R8UintPack32";
+      case Format::eA8B8G8R8SintPack32 : return "A8B8G8R8SintPack32";
+      case Format::eA8B8G8R8SrgbPack32 : return "A8B8G8R8SrgbPack32";
+      case Format::eA2R10G10B10UnormPack32 : return "A2R10G10B10UnormPack32";
+      case Format::eA2R10G10B10SnormPack32 : return "A2R10G10B10SnormPack32";
+      case Format::eA2R10G10B10UscaledPack32 : return "A2R10G10B10UscaledPack32";
+      case Format::eA2R10G10B10SscaledPack32 : return "A2R10G10B10SscaledPack32";
+      case Format::eA2R10G10B10UintPack32 : return "A2R10G10B10UintPack32";
+      case Format::eA2R10G10B10SintPack32 : return "A2R10G10B10SintPack32";
+      case Format::eA2B10G10R10UnormPack32 : return "A2B10G10R10UnormPack32";
+      case Format::eA2B10G10R10SnormPack32 : return "A2B10G10R10SnormPack32";
+      case Format::eA2B10G10R10UscaledPack32 : return "A2B10G10R10UscaledPack32";
+      case Format::eA2B10G10R10SscaledPack32 : return "A2B10G10R10SscaledPack32";
+      case Format::eA2B10G10R10UintPack32 : return "A2B10G10R10UintPack32";
+      case Format::eA2B10G10R10SintPack32 : return "A2B10G10R10SintPack32";
+      case Format::eR16Unorm : return "R16Unorm";
+      case Format::eR16Snorm : return "R16Snorm";
+      case Format::eR16Uscaled : return "R16Uscaled";
+      case Format::eR16Sscaled : return "R16Sscaled";
+      case Format::eR16Uint : return "R16Uint";
+      case Format::eR16Sint : return "R16Sint";
+      case Format::eR16Sfloat : return "R16Sfloat";
+      case Format::eR16G16Unorm : return "R16G16Unorm";
+      case Format::eR16G16Snorm : return "R16G16Snorm";
+      case Format::eR16G16Uscaled : return "R16G16Uscaled";
+      case Format::eR16G16Sscaled : return "R16G16Sscaled";
+      case Format::eR16G16Uint : return "R16G16Uint";
+      case Format::eR16G16Sint : return "R16G16Sint";
+      case Format::eR16G16Sfloat : return "R16G16Sfloat";
+      case Format::eR16G16B16Unorm : return "R16G16B16Unorm";
+      case Format::eR16G16B16Snorm : return "R16G16B16Snorm";
+      case Format::eR16G16B16Uscaled : return "R16G16B16Uscaled";
+      case Format::eR16G16B16Sscaled : return "R16G16B16Sscaled";
+      case Format::eR16G16B16Uint : return "R16G16B16Uint";
+      case Format::eR16G16B16Sint : return "R16G16B16Sint";
+      case Format::eR16G16B16Sfloat : return "R16G16B16Sfloat";
+      case Format::eR16G16B16A16Unorm : return "R16G16B16A16Unorm";
+      case Format::eR16G16B16A16Snorm : return "R16G16B16A16Snorm";
+      case Format::eR16G16B16A16Uscaled : return "R16G16B16A16Uscaled";
+      case Format::eR16G16B16A16Sscaled : return "R16G16B16A16Sscaled";
+      case Format::eR16G16B16A16Uint : return "R16G16B16A16Uint";
+      case Format::eR16G16B16A16Sint : return "R16G16B16A16Sint";
+      case Format::eR16G16B16A16Sfloat : return "R16G16B16A16Sfloat";
+      case Format::eR32Uint : return "R32Uint";
+      case Format::eR32Sint : return "R32Sint";
+      case Format::eR32Sfloat : return "R32Sfloat";
+      case Format::eR32G32Uint : return "R32G32Uint";
+      case Format::eR32G32Sint : return "R32G32Sint";
+      case Format::eR32G32Sfloat : return "R32G32Sfloat";
+      case Format::eR32G32B32Uint : return "R32G32B32Uint";
+      case Format::eR32G32B32Sint : return "R32G32B32Sint";
+      case Format::eR32G32B32Sfloat : return "R32G32B32Sfloat";
+      case Format::eR32G32B32A32Uint : return "R32G32B32A32Uint";
+      case Format::eR32G32B32A32Sint : return "R32G32B32A32Sint";
+      case Format::eR32G32B32A32Sfloat : return "R32G32B32A32Sfloat";
+      case Format::eR64Uint : return "R64Uint";
+      case Format::eR64Sint : return "R64Sint";
+      case Format::eR64Sfloat : return "R64Sfloat";
+      case Format::eR64G64Uint : return "R64G64Uint";
+      case Format::eR64G64Sint : return "R64G64Sint";
+      case Format::eR64G64Sfloat : return "R64G64Sfloat";
+      case Format::eR64G64B64Uint : return "R64G64B64Uint";
+      case Format::eR64G64B64Sint : return "R64G64B64Sint";
+      case Format::eR64G64B64Sfloat : return "R64G64B64Sfloat";
+      case Format::eR64G64B64A64Uint : return "R64G64B64A64Uint";
+      case Format::eR64G64B64A64Sint : return "R64G64B64A64Sint";
+      case Format::eR64G64B64A64Sfloat : return "R64G64B64A64Sfloat";
+      case Format::eB10G11R11UfloatPack32 : return "B10G11R11UfloatPack32";
+      case Format::eE5B9G9R9UfloatPack32 : return "E5B9G9R9UfloatPack32";
+      case Format::eD16Unorm : return "D16Unorm";
+      case Format::eX8D24UnormPack32 : return "X8D24UnormPack32";
+      case Format::eD32Sfloat : return "D32Sfloat";
+      case Format::eS8Uint : return "S8Uint";
+      case Format::eD16UnormS8Uint : return "D16UnormS8Uint";
+      case Format::eD24UnormS8Uint : return "D24UnormS8Uint";
+      case Format::eD32SfloatS8Uint : return "D32SfloatS8Uint";
+      case Format::eBc1RgbUnormBlock : return "Bc1RgbUnormBlock";
+      case Format::eBc1RgbSrgbBlock : return "Bc1RgbSrgbBlock";
+      case Format::eBc1RgbaUnormBlock : return "Bc1RgbaUnormBlock";
+      case Format::eBc1RgbaSrgbBlock : return "Bc1RgbaSrgbBlock";
+      case Format::eBc2UnormBlock : return "Bc2UnormBlock";
+      case Format::eBc2SrgbBlock : return "Bc2SrgbBlock";
+      case Format::eBc3UnormBlock : return "Bc3UnormBlock";
+      case Format::eBc3SrgbBlock : return "Bc3SrgbBlock";
+      case Format::eBc4UnormBlock : return "Bc4UnormBlock";
+      case Format::eBc4SnormBlock : return "Bc4SnormBlock";
+      case Format::eBc5UnormBlock : return "Bc5UnormBlock";
+      case Format::eBc5SnormBlock : return "Bc5SnormBlock";
+      case Format::eBc6HUfloatBlock : return "Bc6HUfloatBlock";
+      case Format::eBc6HSfloatBlock : return "Bc6HSfloatBlock";
+      case Format::eBc7UnormBlock : return "Bc7UnormBlock";
+      case Format::eBc7SrgbBlock : return "Bc7SrgbBlock";
+      case Format::eEtc2R8G8B8UnormBlock : return "Etc2R8G8B8UnormBlock";
+      case Format::eEtc2R8G8B8SrgbBlock : return "Etc2R8G8B8SrgbBlock";
+      case Format::eEtc2R8G8B8A1UnormBlock : return "Etc2R8G8B8A1UnormBlock";
+      case Format::eEtc2R8G8B8A1SrgbBlock : return "Etc2R8G8B8A1SrgbBlock";
+      case Format::eEtc2R8G8B8A8UnormBlock : return "Etc2R8G8B8A8UnormBlock";
+      case Format::eEtc2R8G8B8A8SrgbBlock : return "Etc2R8G8B8A8SrgbBlock";
+      case Format::eEacR11UnormBlock : return "EacR11UnormBlock";
+      case Format::eEacR11SnormBlock : return "EacR11SnormBlock";
+      case Format::eEacR11G11UnormBlock : return "EacR11G11UnormBlock";
+      case Format::eEacR11G11SnormBlock : return "EacR11G11SnormBlock";
+      case Format::eAstc4x4UnormBlock : return "Astc4x4UnormBlock";
+      case Format::eAstc4x4SrgbBlock : return "Astc4x4SrgbBlock";
+      case Format::eAstc5x4UnormBlock : return "Astc5x4UnormBlock";
+      case Format::eAstc5x4SrgbBlock : return "Astc5x4SrgbBlock";
+      case Format::eAstc5x5UnormBlock : return "Astc5x5UnormBlock";
+      case Format::eAstc5x5SrgbBlock : return "Astc5x5SrgbBlock";
+      case Format::eAstc6x5UnormBlock : return "Astc6x5UnormBlock";
+      case Format::eAstc6x5SrgbBlock : return "Astc6x5SrgbBlock";
+      case Format::eAstc6x6UnormBlock : return "Astc6x6UnormBlock";
+      case Format::eAstc6x6SrgbBlock : return "Astc6x6SrgbBlock";
+      case Format::eAstc8x5UnormBlock : return "Astc8x5UnormBlock";
+      case Format::eAstc8x5SrgbBlock : return "Astc8x5SrgbBlock";
+      case Format::eAstc8x6UnormBlock : return "Astc8x6UnormBlock";
+      case Format::eAstc8x6SrgbBlock : return "Astc8x6SrgbBlock";
+      case Format::eAstc8x8UnormBlock : return "Astc8x8UnormBlock";
+      case Format::eAstc8x8SrgbBlock : return "Astc8x8SrgbBlock";
+      case Format::eAstc10x5UnormBlock : return "Astc10x5UnormBlock";
+      case Format::eAstc10x5SrgbBlock : return "Astc10x5SrgbBlock";
+      case Format::eAstc10x6UnormBlock : return "Astc10x6UnormBlock";
+      case Format::eAstc10x6SrgbBlock : return "Astc10x6SrgbBlock";
+      case Format::eAstc10x8UnormBlock : return "Astc10x8UnormBlock";
+      case Format::eAstc10x8SrgbBlock : return "Astc10x8SrgbBlock";
+      case Format::eAstc10x10UnormBlock : return "Astc10x10UnormBlock";
+      case Format::eAstc10x10SrgbBlock : return "Astc10x10SrgbBlock";
+      case Format::eAstc12x10UnormBlock : return "Astc12x10UnormBlock";
+      case Format::eAstc12x10SrgbBlock : return "Astc12x10SrgbBlock";
+      case Format::eAstc12x12UnormBlock : return "Astc12x12UnormBlock";
+      case Format::eAstc12x12SrgbBlock : return "Astc12x12SrgbBlock";
+      case Format::eG8B8G8R8422Unorm : return "G8B8G8R8422Unorm";
+      case Format::eB8G8R8G8422Unorm : return "B8G8R8G8422Unorm";
+      case Format::eG8B8R83Plane420Unorm : return "G8B8R83Plane420Unorm";
+      case Format::eG8B8R82Plane420Unorm : return "G8B8R82Plane420Unorm";
+      case Format::eG8B8R83Plane422Unorm : return "G8B8R83Plane422Unorm";
+      case Format::eG8B8R82Plane422Unorm : return "G8B8R82Plane422Unorm";
+      case Format::eG8B8R83Plane444Unorm : return "G8B8R83Plane444Unorm";
+      case Format::eR10X6UnormPack16 : return "R10X6UnormPack16";
+      case Format::eR10X6G10X6Unorm2Pack16 : return "R10X6G10X6Unorm2Pack16";
+      case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "R10X6G10X6B10X6A10X6Unorm4Pack16";
+      case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
+      case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
+      case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "G10X6B10X6R10X63Plane420Unorm3Pack16";
+      case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "G10X6B10X6R10X62Plane420Unorm3Pack16";
+      case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "G10X6B10X6R10X63Plane422Unorm3Pack16";
+      case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "G10X6B10X6R10X62Plane422Unorm3Pack16";
+      case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "G10X6B10X6R10X63Plane444Unorm3Pack16";
+      case Format::eR12X4UnormPack16 : return "R12X4UnormPack16";
+      case Format::eR12X4G12X4Unorm2Pack16 : return "R12X4G12X4Unorm2Pack16";
+      case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "R12X4G12X4B12X4A12X4Unorm4Pack16";
+      case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
+      case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
+      case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "G12X4B12X4R12X43Plane420Unorm3Pack16";
+      case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "G12X4B12X4R12X42Plane420Unorm3Pack16";
+      case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "G12X4B12X4R12X43Plane422Unorm3Pack16";
+      case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "G12X4B12X4R12X42Plane422Unorm3Pack16";
+      case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "G12X4B12X4R12X43Plane444Unorm3Pack16";
+      case Format::eG16B16G16R16422Unorm : return "G16B16G16R16422Unorm";
+      case Format::eB16G16R16G16422Unorm : return "B16G16R16G16422Unorm";
+      case Format::eG16B16R163Plane420Unorm : return "G16B16R163Plane420Unorm";
+      case Format::eG16B16R162Plane420Unorm : return "G16B16R162Plane420Unorm";
+      case Format::eG16B16R163Plane422Unorm : return "G16B16R163Plane422Unorm";
+      case Format::eG16B16R162Plane422Unorm : return "G16B16R162Plane422Unorm";
+      case Format::eG16B16R163Plane444Unorm : return "G16B16R163Plane444Unorm";
+      case Format::ePvrtc12BppUnormBlockIMG : return "Pvrtc12BppUnormBlockIMG";
+      case Format::ePvrtc14BppUnormBlockIMG : return "Pvrtc14BppUnormBlockIMG";
+      case Format::ePvrtc22BppUnormBlockIMG : return "Pvrtc22BppUnormBlockIMG";
+      case Format::ePvrtc24BppUnormBlockIMG : return "Pvrtc24BppUnormBlockIMG";
+      case Format::ePvrtc12BppSrgbBlockIMG : return "Pvrtc12BppSrgbBlockIMG";
+      case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG";
+      case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG";
+      case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG";
+      default: return "invalid";
     }
+  }
 
-    VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
-    }
-
-    VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
-      return *this;
-    }
-    VertexInputAttributeDescription& setLocation( uint32_t location_ )
-    {
-      location = location_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    operator VkVertexInputAttributeDescription const&() const
-    {
-      return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this);
-    }
-
-    operator VkVertexInputAttributeDescription &()
-    {
-      return *reinterpret_cast<VkVertexInputAttributeDescription*>(this);
-    }
-
-    bool operator==( VertexInputAttributeDescription const& rhs ) const
-    {
-      return ( location == rhs.location )
-          && ( binding == rhs.binding )
-          && ( format == rhs.format )
-          && ( offset == rhs.offset );
-    }
-
-    bool operator!=( VertexInputAttributeDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t location;
-    uint32_t binding;
-    Format format;
-    uint32_t offset;
+  enum class FrontFace
+  {
+    eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+    eClockwise = VK_FRONT_FACE_CLOCKWISE
   };
-  static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
+
+  VULKAN_HPP_INLINE std::string to_string( FrontFace value )
+  {
+    switch ( value )
+    {
+      case FrontFace::eCounterClockwise : return "CounterClockwise";
+      case FrontFace::eClockwise : return "Clockwise";
+      default: return "invalid";
+    }
+  }
+
+  enum class GeometryTypeNV
+  {
+    eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV,
+    eAabbs = VK_GEOMETRY_TYPE_AABBS_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( GeometryTypeNV value )
+  {
+    switch ( value )
+    {
+      case GeometryTypeNV::eTriangles : return "Triangles";
+      case GeometryTypeNV::eAabbs : return "Aabbs";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageLayout
+  {
+    eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
+    eGeneral = VK_IMAGE_LAYOUT_GENERAL,
+    eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+    eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+    eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+    eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+    eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+    ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
+    eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+    eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+    ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+    eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
+    eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV,
+    eFragmentDensityMapOptimalEXT = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,
+    eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR,
+    eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageLayout value )
+  {
+    switch ( value )
+    {
+      case ImageLayout::eUndefined : return "Undefined";
+      case ImageLayout::eGeneral : return "General";
+      case ImageLayout::eColorAttachmentOptimal : return "ColorAttachmentOptimal";
+      case ImageLayout::eDepthStencilAttachmentOptimal : return "DepthStencilAttachmentOptimal";
+      case ImageLayout::eDepthStencilReadOnlyOptimal : return "DepthStencilReadOnlyOptimal";
+      case ImageLayout::eShaderReadOnlyOptimal : return "ShaderReadOnlyOptimal";
+      case ImageLayout::eTransferSrcOptimal : return "TransferSrcOptimal";
+      case ImageLayout::eTransferDstOptimal : return "TransferDstOptimal";
+      case ImageLayout::ePreinitialized : return "Preinitialized";
+      case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal : return "DepthReadOnlyStencilAttachmentOptimal";
+      case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal : return "DepthAttachmentStencilReadOnlyOptimal";
+      case ImageLayout::ePresentSrcKHR : return "PresentSrcKHR";
+      case ImageLayout::eSharedPresentKHR : return "SharedPresentKHR";
+      case ImageLayout::eShadingRateOptimalNV : return "ShadingRateOptimalNV";
+      case ImageLayout::eFragmentDensityMapOptimalEXT : return "FragmentDensityMapOptimalEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageTiling
+  {
+    eOptimal = VK_IMAGE_TILING_OPTIMAL,
+    eLinear = VK_IMAGE_TILING_LINEAR,
+    eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageTiling value )
+  {
+    switch ( value )
+    {
+      case ImageTiling::eOptimal : return "Optimal";
+      case ImageTiling::eLinear : return "Linear";
+      case ImageTiling::eDrmFormatModifierEXT : return "DrmFormatModifierEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageType
+  {
+    e1D = VK_IMAGE_TYPE_1D,
+    e2D = VK_IMAGE_TYPE_2D,
+    e3D = VK_IMAGE_TYPE_3D
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageType value )
+  {
+    switch ( value )
+    {
+      case ImageType::e1D : return "1D";
+      case ImageType::e2D : return "2D";
+      case ImageType::e3D : return "3D";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageViewType
+  {
+    e1D = VK_IMAGE_VIEW_TYPE_1D,
+    e2D = VK_IMAGE_VIEW_TYPE_2D,
+    e3D = VK_IMAGE_VIEW_TYPE_3D,
+    eCube = VK_IMAGE_VIEW_TYPE_CUBE,
+    e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
+    e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
+    eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageViewType value )
+  {
+    switch ( value )
+    {
+      case ImageViewType::e1D : return "1D";
+      case ImageViewType::e2D : return "2D";
+      case ImageViewType::e3D : return "3D";
+      case ImageViewType::eCube : return "Cube";
+      case ImageViewType::e1DArray : return "1DArray";
+      case ImageViewType::e2DArray : return "2DArray";
+      case ImageViewType::eCubeArray : return "CubeArray";
+      default: return "invalid";
+    }
+  }
+
+  enum class IndexType
+  {
+    eUint16 = VK_INDEX_TYPE_UINT16,
+    eUint32 = VK_INDEX_TYPE_UINT32,
+    eNoneNV = VK_INDEX_TYPE_NONE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( IndexType value )
+  {
+    switch ( value )
+    {
+      case IndexType::eUint16 : return "Uint16";
+      case IndexType::eUint32 : return "Uint32";
+      case IndexType::eNoneNV : return "NoneNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class IndirectCommandsTokenTypeNVX
+  {
+    ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
+    eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX,
+    eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX,
+    eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX,
+    ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX,
+    eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX,
+    eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX,
+    eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( IndirectCommandsTokenTypeNVX value )
+  {
+    switch ( value )
+    {
+      case IndirectCommandsTokenTypeNVX::ePipeline : return "Pipeline";
+      case IndirectCommandsTokenTypeNVX::eDescriptorSet : return "DescriptorSet";
+      case IndirectCommandsTokenTypeNVX::eIndexBuffer : return "IndexBuffer";
+      case IndirectCommandsTokenTypeNVX::eVertexBuffer : return "VertexBuffer";
+      case IndirectCommandsTokenTypeNVX::ePushConstant : return "PushConstant";
+      case IndirectCommandsTokenTypeNVX::eDrawIndexed : return "DrawIndexed";
+      case IndirectCommandsTokenTypeNVX::eDraw : return "Draw";
+      case IndirectCommandsTokenTypeNVX::eDispatch : return "Dispatch";
+      default: return "invalid";
+    }
+  }
+
+  enum class InternalAllocationType
+  {
+    eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( InternalAllocationType value )
+  {
+    switch ( value )
+    {
+      case InternalAllocationType::eExecutable : return "Executable";
+      default: return "invalid";
+    }
+  }
+
+  enum class LogicOp
+  {
+    eClear = VK_LOGIC_OP_CLEAR,
+    eAnd = VK_LOGIC_OP_AND,
+    eAndReverse = VK_LOGIC_OP_AND_REVERSE,
+    eCopy = VK_LOGIC_OP_COPY,
+    eAndInverted = VK_LOGIC_OP_AND_INVERTED,
+    eNoOp = VK_LOGIC_OP_NO_OP,
+    eXor = VK_LOGIC_OP_XOR,
+    eOr = VK_LOGIC_OP_OR,
+    eNor = VK_LOGIC_OP_NOR,
+    eEquivalent = VK_LOGIC_OP_EQUIVALENT,
+    eInvert = VK_LOGIC_OP_INVERT,
+    eOrReverse = VK_LOGIC_OP_OR_REVERSE,
+    eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
+    eOrInverted = VK_LOGIC_OP_OR_INVERTED,
+    eNand = VK_LOGIC_OP_NAND,
+    eSet = VK_LOGIC_OP_SET
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( LogicOp value )
+  {
+    switch ( value )
+    {
+      case LogicOp::eClear : return "Clear";
+      case LogicOp::eAnd : return "And";
+      case LogicOp::eAndReverse : return "AndReverse";
+      case LogicOp::eCopy : return "Copy";
+      case LogicOp::eAndInverted : return "AndInverted";
+      case LogicOp::eNoOp : return "NoOp";
+      case LogicOp::eXor : return "Xor";
+      case LogicOp::eOr : return "Or";
+      case LogicOp::eNor : return "Nor";
+      case LogicOp::eEquivalent : return "Equivalent";
+      case LogicOp::eInvert : return "Invert";
+      case LogicOp::eOrReverse : return "OrReverse";
+      case LogicOp::eCopyInverted : return "CopyInverted";
+      case LogicOp::eOrInverted : return "OrInverted";
+      case LogicOp::eNand : return "Nand";
+      case LogicOp::eSet : return "Set";
+      default: return "invalid";
+    }
+  }
+
+  enum class MemoryOverallocationBehaviorAMD
+  {
+    eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
+    eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD,
+    eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryOverallocationBehaviorAMD value )
+  {
+    switch ( value )
+    {
+      case MemoryOverallocationBehaviorAMD::eDefault : return "Default";
+      case MemoryOverallocationBehaviorAMD::eAllowed : return "Allowed";
+      case MemoryOverallocationBehaviorAMD::eDisallowed : return "Disallowed";
+      default: return "invalid";
+    }
+  }
+
+  enum class ObjectEntryTypeNVX
+  {
+    eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
+    ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX,
+    eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX,
+    eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX,
+    ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ObjectEntryTypeNVX value )
+  {
+    switch ( value )
+    {
+      case ObjectEntryTypeNVX::eDescriptorSet : return "DescriptorSet";
+      case ObjectEntryTypeNVX::ePipeline : return "Pipeline";
+      case ObjectEntryTypeNVX::eIndexBuffer : return "IndexBuffer";
+      case ObjectEntryTypeNVX::eVertexBuffer : return "VertexBuffer";
+      case ObjectEntryTypeNVX::ePushConstant : return "PushConstant";
+      default: return "invalid";
+    }
+  }
+
+  enum class ObjectType
+  {
+    eUnknown = VK_OBJECT_TYPE_UNKNOWN,
+    eInstance = VK_OBJECT_TYPE_INSTANCE,
+    ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
+    eDevice = VK_OBJECT_TYPE_DEVICE,
+    eQueue = VK_OBJECT_TYPE_QUEUE,
+    eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
+    eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
+    eFence = VK_OBJECT_TYPE_FENCE,
+    eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
+    eBuffer = VK_OBJECT_TYPE_BUFFER,
+    eImage = VK_OBJECT_TYPE_IMAGE,
+    eEvent = VK_OBJECT_TYPE_EVENT,
+    eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
+    eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
+    eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
+    eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
+    ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
+    ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
+    eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
+    ePipeline = VK_OBJECT_TYPE_PIPELINE,
+    eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+    eSampler = VK_OBJECT_TYPE_SAMPLER,
+    eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+    eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
+    eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
+    eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
+    eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+    eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+    eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
+    eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
+    eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
+    eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
+    eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
+    eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
+    eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX,
+    eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,
+    eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT,
+    eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV,
+    eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR,
+    eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ObjectType value )
+  {
+    switch ( value )
+    {
+      case ObjectType::eUnknown : return "Unknown";
+      case ObjectType::eInstance : return "Instance";
+      case ObjectType::ePhysicalDevice : return "PhysicalDevice";
+      case ObjectType::eDevice : return "Device";
+      case ObjectType::eQueue : return "Queue";
+      case ObjectType::eSemaphore : return "Semaphore";
+      case ObjectType::eCommandBuffer : return "CommandBuffer";
+      case ObjectType::eFence : return "Fence";
+      case ObjectType::eDeviceMemory : return "DeviceMemory";
+      case ObjectType::eBuffer : return "Buffer";
+      case ObjectType::eImage : return "Image";
+      case ObjectType::eEvent : return "Event";
+      case ObjectType::eQueryPool : return "QueryPool";
+      case ObjectType::eBufferView : return "BufferView";
+      case ObjectType::eImageView : return "ImageView";
+      case ObjectType::eShaderModule : return "ShaderModule";
+      case ObjectType::ePipelineCache : return "PipelineCache";
+      case ObjectType::ePipelineLayout : return "PipelineLayout";
+      case ObjectType::eRenderPass : return "RenderPass";
+      case ObjectType::ePipeline : return "Pipeline";
+      case ObjectType::eDescriptorSetLayout : return "DescriptorSetLayout";
+      case ObjectType::eSampler : return "Sampler";
+      case ObjectType::eDescriptorPool : return "DescriptorPool";
+      case ObjectType::eDescriptorSet : return "DescriptorSet";
+      case ObjectType::eFramebuffer : return "Framebuffer";
+      case ObjectType::eCommandPool : return "CommandPool";
+      case ObjectType::eSamplerYcbcrConversion : return "SamplerYcbcrConversion";
+      case ObjectType::eDescriptorUpdateTemplate : return "DescriptorUpdateTemplate";
+      case ObjectType::eSurfaceKHR : return "SurfaceKHR";
+      case ObjectType::eSwapchainKHR : return "SwapchainKHR";
+      case ObjectType::eDisplayKHR : return "DisplayKHR";
+      case ObjectType::eDisplayModeKHR : return "DisplayModeKHR";
+      case ObjectType::eDebugReportCallbackEXT : return "DebugReportCallbackEXT";
+      case ObjectType::eObjectTableNVX : return "ObjectTableNVX";
+      case ObjectType::eIndirectCommandsLayoutNVX : return "IndirectCommandsLayoutNVX";
+      case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT";
+      case ObjectType::eValidationCacheEXT : return "ValidationCacheEXT";
+      case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class PhysicalDeviceType
+  {
+    eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
+    eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
+    eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
+    eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
+    eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceType value )
+  {
+    switch ( value )
+    {
+      case PhysicalDeviceType::eOther : return "Other";
+      case PhysicalDeviceType::eIntegratedGpu : return "IntegratedGpu";
+      case PhysicalDeviceType::eDiscreteGpu : return "DiscreteGpu";
+      case PhysicalDeviceType::eVirtualGpu : return "VirtualGpu";
+      case PhysicalDeviceType::eCpu : return "Cpu";
+      default: return "invalid";
+    }
+  }
+
+  enum class PipelineBindPoint
+  {
+    eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
+    eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
+    eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineBindPoint value )
+  {
+    switch ( value )
+    {
+      case PipelineBindPoint::eGraphics : return "Graphics";
+      case PipelineBindPoint::eCompute : return "Compute";
+      case PipelineBindPoint::eRayTracingNV : return "RayTracingNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class PipelineCacheHeaderVersion
+  {
+    eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCacheHeaderVersion value )
+  {
+    switch ( value )
+    {
+      case PipelineCacheHeaderVersion::eOne : return "One";
+      default: return "invalid";
+    }
+  }
+
+  enum class PointClippingBehavior
+  {
+    eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+    eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
+    eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR,
+    eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PointClippingBehavior value )
+  {
+    switch ( value )
+    {
+      case PointClippingBehavior::eAllClipPlanes : return "AllClipPlanes";
+      case PointClippingBehavior::eUserClipPlanesOnly : return "UserClipPlanesOnly";
+      default: return "invalid";
+    }
+  }
+
+  enum class PolygonMode
+  {
+    eFill = VK_POLYGON_MODE_FILL,
+    eLine = VK_POLYGON_MODE_LINE,
+    ePoint = VK_POLYGON_MODE_POINT,
+    eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PolygonMode value )
+  {
+    switch ( value )
+    {
+      case PolygonMode::eFill : return "Fill";
+      case PolygonMode::eLine : return "Line";
+      case PolygonMode::ePoint : return "Point";
+      case PolygonMode::eFillRectangleNV : return "FillRectangleNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class PresentModeKHR
+  {
+    eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
+    eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
+    eFifo = VK_PRESENT_MODE_FIFO_KHR,
+    eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+    eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
+    eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PresentModeKHR value )
+  {
+    switch ( value )
+    {
+      case PresentModeKHR::eImmediate : return "Immediate";
+      case PresentModeKHR::eMailbox : return "Mailbox";
+      case PresentModeKHR::eFifo : return "Fifo";
+      case PresentModeKHR::eFifoRelaxed : return "FifoRelaxed";
+      case PresentModeKHR::eSharedDemandRefresh : return "SharedDemandRefresh";
+      case PresentModeKHR::eSharedContinuousRefresh : return "SharedContinuousRefresh";
+      default: return "invalid";
+    }
+  }
+
+  enum class PrimitiveTopology
+  {
+    ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
+    eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
+    eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
+    eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
+    eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+    eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
+    eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
+    eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
+    eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
+    eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
+    ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PrimitiveTopology value )
+  {
+    switch ( value )
+    {
+      case PrimitiveTopology::ePointList : return "PointList";
+      case PrimitiveTopology::eLineList : return "LineList";
+      case PrimitiveTopology::eLineStrip : return "LineStrip";
+      case PrimitiveTopology::eTriangleList : return "TriangleList";
+      case PrimitiveTopology::eTriangleStrip : return "TriangleStrip";
+      case PrimitiveTopology::eTriangleFan : return "TriangleFan";
+      case PrimitiveTopology::eLineListWithAdjacency : return "LineListWithAdjacency";
+      case PrimitiveTopology::eLineStripWithAdjacency : return "LineStripWithAdjacency";
+      case PrimitiveTopology::eTriangleListWithAdjacency : return "TriangleListWithAdjacency";
+      case PrimitiveTopology::eTriangleStripWithAdjacency : return "TriangleStripWithAdjacency";
+      case PrimitiveTopology::ePatchList : return "PatchList";
+      default: return "invalid";
+    }
+  }
+
+  enum class QueryType
+  {
+    eOcclusion = VK_QUERY_TYPE_OCCLUSION,
+    ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
+    eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
+    eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
+    eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryType value )
+  {
+    switch ( value )
+    {
+      case QueryType::eOcclusion : return "Occlusion";
+      case QueryType::ePipelineStatistics : return "PipelineStatistics";
+      case QueryType::eTimestamp : return "Timestamp";
+      case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT";
+      case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class QueueGlobalPriorityEXT
+  {
+    eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
+    eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
+    eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
+    eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueueGlobalPriorityEXT value )
+  {
+    switch ( value )
+    {
+      case QueueGlobalPriorityEXT::eLow : return "Low";
+      case QueueGlobalPriorityEXT::eMedium : return "Medium";
+      case QueueGlobalPriorityEXT::eHigh : return "High";
+      case QueueGlobalPriorityEXT::eRealtime : return "Realtime";
+      default: return "invalid";
+    }
+  }
+
+  enum class RasterizationOrderAMD
+  {
+    eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
+    eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( RasterizationOrderAMD value )
+  {
+    switch ( value )
+    {
+      case RasterizationOrderAMD::eStrict : return "Strict";
+      case RasterizationOrderAMD::eRelaxed : return "Relaxed";
+      default: return "invalid";
+    }
+  }
+
+  enum class RayTracingShaderGroupTypeNV
+  {
+    eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,
+    eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV,
+    eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( RayTracingShaderGroupTypeNV value )
+  {
+    switch ( value )
+    {
+      case RayTracingShaderGroupTypeNV::eGeneral : return "General";
+      case RayTracingShaderGroupTypeNV::eTrianglesHitGroup : return "TrianglesHitGroup";
+      case RayTracingShaderGroupTypeNV::eProceduralHitGroup : return "ProceduralHitGroup";
+      default: return "invalid";
+    }
+  }
+
+  enum class Result
+  {
+    eSuccess = VK_SUCCESS,
+    eNotReady = VK_NOT_READY,
+    eTimeout = VK_TIMEOUT,
+    eEventSet = VK_EVENT_SET,
+    eEventReset = VK_EVENT_RESET,
+    eIncomplete = VK_INCOMPLETE,
+    eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
+    eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
+    eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
+    eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
+    eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
+    eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
+    eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
+    eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
+    eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
+    eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
+    eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
+    eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
+    eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY,
+    eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+    eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR,
+    eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
+    eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
+    eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
+    eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
+    eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
+    eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
+    eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
+    eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT,
+    eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT,
+    eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT,
+    eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR,
+    eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( Result value )
+  {
+    switch ( value )
+    {
+      case Result::eSuccess : return "Success";
+      case Result::eNotReady : return "NotReady";
+      case Result::eTimeout : return "Timeout";
+      case Result::eEventSet : return "EventSet";
+      case Result::eEventReset : return "EventReset";
+      case Result::eIncomplete : return "Incomplete";
+      case Result::eErrorOutOfHostMemory : return "ErrorOutOfHostMemory";
+      case Result::eErrorOutOfDeviceMemory : return "ErrorOutOfDeviceMemory";
+      case Result::eErrorInitializationFailed : return "ErrorInitializationFailed";
+      case Result::eErrorDeviceLost : return "ErrorDeviceLost";
+      case Result::eErrorMemoryMapFailed : return "ErrorMemoryMapFailed";
+      case Result::eErrorLayerNotPresent : return "ErrorLayerNotPresent";
+      case Result::eErrorExtensionNotPresent : return "ErrorExtensionNotPresent";
+      case Result::eErrorFeatureNotPresent : return "ErrorFeatureNotPresent";
+      case Result::eErrorIncompatibleDriver : return "ErrorIncompatibleDriver";
+      case Result::eErrorTooManyObjects : return "ErrorTooManyObjects";
+      case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported";
+      case Result::eErrorFragmentedPool : return "ErrorFragmentedPool";
+      case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory";
+      case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle";
+      case Result::eErrorSurfaceLostKHR : return "ErrorSurfaceLostKHR";
+      case Result::eErrorNativeWindowInUseKHR : return "ErrorNativeWindowInUseKHR";
+      case Result::eSuboptimalKHR : return "SuboptimalKHR";
+      case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR";
+      case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR";
+      case Result::eErrorValidationFailedEXT : return "ErrorValidationFailedEXT";
+      case Result::eErrorInvalidShaderNV : return "ErrorInvalidShaderNV";
+      case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT : return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
+      case Result::eErrorFragmentationEXT : return "ErrorFragmentationEXT";
+      case Result::eErrorNotPermittedEXT : return "ErrorNotPermittedEXT";
+      case Result::eErrorInvalidDeviceAddressEXT : return "ErrorInvalidDeviceAddressEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerAddressMode
+  {
+    eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+    eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
+    eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+    eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
+    eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerAddressMode value )
+  {
+    switch ( value )
+    {
+      case SamplerAddressMode::eRepeat : return "Repeat";
+      case SamplerAddressMode::eMirroredRepeat : return "MirroredRepeat";
+      case SamplerAddressMode::eClampToEdge : return "ClampToEdge";
+      case SamplerAddressMode::eClampToBorder : return "ClampToBorder";
+      case SamplerAddressMode::eMirrorClampToEdge : return "MirrorClampToEdge";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerMipmapMode
+  {
+    eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
+    eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerMipmapMode value )
+  {
+    switch ( value )
+    {
+      case SamplerMipmapMode::eNearest : return "Nearest";
+      case SamplerMipmapMode::eLinear : return "Linear";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerReductionModeEXT
+  {
+    eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
+    eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT,
+    eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerReductionModeEXT value )
+  {
+    switch ( value )
+    {
+      case SamplerReductionModeEXT::eWeightedAverage : return "WeightedAverage";
+      case SamplerReductionModeEXT::eMin : return "Min";
+      case SamplerReductionModeEXT::eMax : return "Max";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerYcbcrModelConversion
+  {
+    eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+    eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+    eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
+    eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+    eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
+    eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
+    eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR,
+    eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR,
+    eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR,
+    eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrModelConversion value )
+  {
+    switch ( value )
+    {
+      case SamplerYcbcrModelConversion::eRgbIdentity : return "RgbIdentity";
+      case SamplerYcbcrModelConversion::eYcbcrIdentity : return "YcbcrIdentity";
+      case SamplerYcbcrModelConversion::eYcbcr709 : return "Ycbcr709";
+      case SamplerYcbcrModelConversion::eYcbcr601 : return "Ycbcr601";
+      case SamplerYcbcrModelConversion::eYcbcr2020 : return "Ycbcr2020";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerYcbcrRange
+  {
+    eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+    eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+    eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
+    eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrRange value )
+  {
+    switch ( value )
+    {
+      case SamplerYcbcrRange::eItuFull : return "ItuFull";
+      case SamplerYcbcrRange::eItuNarrow : return "ItuNarrow";
+      default: return "invalid";
+    }
+  }
+
+  enum class ScopeNV
+  {
+    eDevice = VK_SCOPE_DEVICE_NV,
+    eWorkgroup = VK_SCOPE_WORKGROUP_NV,
+    eSubgroup = VK_SCOPE_SUBGROUP_NV,
+    eQueueFamily = VK_SCOPE_QUEUE_FAMILY_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ScopeNV value )
+  {
+    switch ( value )
+    {
+      case ScopeNV::eDevice : return "Device";
+      case ScopeNV::eWorkgroup : return "Workgroup";
+      case ScopeNV::eSubgroup : return "Subgroup";
+      case ScopeNV::eQueueFamily : return "QueueFamily";
+      default: return "invalid";
+    }
+  }
+
+  enum class ShaderInfoTypeAMD
+  {
+    eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
+    eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
+    eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderInfoTypeAMD value )
+  {
+    switch ( value )
+    {
+      case ShaderInfoTypeAMD::eStatistics : return "Statistics";
+      case ShaderInfoTypeAMD::eBinary : return "Binary";
+      case ShaderInfoTypeAMD::eDisassembly : return "Disassembly";
+      default: return "invalid";
+    }
+  }
+
+  enum class ShadingRatePaletteEntryNV
+  {
+    eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
+    e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV,
+    e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV,
+    e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV,
+    e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV,
+    e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV,
+    e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV,
+    e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV,
+    e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV,
+    e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV,
+    e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV,
+    e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ShadingRatePaletteEntryNV value )
+  {
+    switch ( value )
+    {
+      case ShadingRatePaletteEntryNV::eNoInvocations : return "NoInvocations";
+      case ShadingRatePaletteEntryNV::e16InvocationsPerPixel : return "16InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e8InvocationsPerPixel : return "8InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e4InvocationsPerPixel : return "4InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e2InvocationsPerPixel : return "2InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e1InvocationPerPixel : return "1InvocationPerPixel";
+      case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels : return "1InvocationPer2X1Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels : return "1InvocationPer1X2Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels : return "1InvocationPer2X2Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels : return "1InvocationPer4X2Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels : return "1InvocationPer2X4Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels : return "1InvocationPer4X4Pixels";
+      default: return "invalid";
+    }
+  }
+
+  enum class SharingMode
+  {
+    eExclusive = VK_SHARING_MODE_EXCLUSIVE,
+    eConcurrent = VK_SHARING_MODE_CONCURRENT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SharingMode value )
+  {
+    switch ( value )
+    {
+      case SharingMode::eExclusive : return "Exclusive";
+      case SharingMode::eConcurrent : return "Concurrent";
+      default: return "invalid";
+    }
+  }
+
+  enum class StencilOp
+  {
+    eKeep = VK_STENCIL_OP_KEEP,
+    eZero = VK_STENCIL_OP_ZERO,
+    eReplace = VK_STENCIL_OP_REPLACE,
+    eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
+    eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
+    eInvert = VK_STENCIL_OP_INVERT,
+    eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
+    eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( StencilOp value )
+  {
+    switch ( value )
+    {
+      case StencilOp::eKeep : return "Keep";
+      case StencilOp::eZero : return "Zero";
+      case StencilOp::eReplace : return "Replace";
+      case StencilOp::eIncrementAndClamp : return "IncrementAndClamp";
+      case StencilOp::eDecrementAndClamp : return "DecrementAndClamp";
+      case StencilOp::eInvert : return "Invert";
+      case StencilOp::eIncrementAndWrap : return "IncrementAndWrap";
+      case StencilOp::eDecrementAndWrap : return "DecrementAndWrap";
+      default: return "invalid";
+    }
+  }
 
   enum class StructureType
   {
@@ -9214,127 +4742,68 @@
     eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
     ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
     eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
-    eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
     eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
-    eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
     ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
-    ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
     eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
-    eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
     eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
-    eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
     eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
-    eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
     eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
-    eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
     eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
-    eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
     eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
-    eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
     eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
-    eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
     eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
-    eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
     eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
-    eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
     ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
-    ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
     eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
-    eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
     eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
-    eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
     eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
-    eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
     eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
-    eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
     eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
-    eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
     eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
-    eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
     ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
-    ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
     ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
-    ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
     eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
-    eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
     eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
-    eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
     ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
-    ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
     eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
-    eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
     ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
-    ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
     eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
-    eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
     ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
-    ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
     ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
-    ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
     eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
-    eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
     eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
-    eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
     ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
-    ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
     eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
-    eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
     ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
-    ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
     ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
-    ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
     ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
-    ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
     eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO,
     ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
     ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
     eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
     eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
-    eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
     eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
-    eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
     eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
-    eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
     eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
-    eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
     ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
-    ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
     eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
-    eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
     eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
-    eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
     ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
-    ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
     eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
-    eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
     ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
-    ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
     eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
-    eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
     ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
-    ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
     eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
-    eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
     eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
-    eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
     eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
-    eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
     ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
-    ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
     eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
-    eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
     eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
-    eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
     eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
-    eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
     ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
-    ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
     eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
-    eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
     ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
-    ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
     eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
-    eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
     ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES,
     eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
     ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
@@ -9350,11 +4819,9 @@
     eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
     eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
     eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
-    eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR,
     eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
     eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
     eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
-    eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
     ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
     eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
     eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
@@ -9365,6 +4832,7 @@
     ePhysicalDeviceTransformFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
     ePhysicalDeviceTransformFeedbackPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
     ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
+    eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX,
     eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
     ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
     eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
@@ -9394,6 +4862,7 @@
     eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
     ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
     eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
+    ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
     ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
     eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX,
     eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX,
@@ -9414,6 +4883,8 @@
     ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
     ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
     ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
+    ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
+    ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
     eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT,
     eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
     eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
@@ -9483,19 +4954,21 @@
     ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
     ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
     ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
-    eRaytracingPipelineCreateInfoNVX = VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX,
-    eAccelerationStructureCreateInfoNVX = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX,
-    eGeometryInstanceNVX = VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX,
-    eGeometryNVX = VK_STRUCTURE_TYPE_GEOMETRY_NVX,
-    eGeometryTrianglesNVX = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX,
-    eGeometryAabbNVX = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX,
-    eBindAccelerationStructureMemoryInfoNVX = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX,
-    eDescriptorAccelerationStructureInfoNVX = VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX,
-    eAccelerationStructureMemoryRequirementsInfoNVX = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX,
-    ePhysicalDeviceRaytracingPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX,
-    eHitShaderModuleCreateInfoNVX = VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX,
+    eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,
+    eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
+    eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV,
+    eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
+    eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV,
+    eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
+    eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
+    eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
+    ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
+    eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
+    eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
     ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
     ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
+    ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
+    eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
     eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
     ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR,
     eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
@@ -9504,10 +4977,14 @@
     ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR,
     eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT,
     ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
+    eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
     ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
     ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
     ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
     ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
+    ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR,
+    ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR,
+    eSubpassDescriptionDepthStencilResolveKHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR,
     ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
     ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
     ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
@@ -9519,9 +4996,12113 @@
     eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
     ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR,
     ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
-    eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA
+    eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
+    eMetalSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT,
+    ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
+    ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
+    eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
+    ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT,
+    ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
+    ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
+    eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
+    ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
+    ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT,
+    eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT,
+    eBufferDeviceAddressCreateInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
+    eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT,
+    eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
+    ePhysicalDeviceCooperativeMatrixFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
+    eCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV,
+    ePhysicalDeviceCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
+    ePhysicalDeviceYcbcrImageArraysFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
+    eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
+    eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR,
+    ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR,
+    ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR,
+    ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
+    ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
+    eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
+    eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+    ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+    eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR,
+    ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR,
+    eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+    ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR,
+    eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR,
+    eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR,
+    eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR,
+    eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR,
+    eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR,
+    eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR,
+    eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR,
+    ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR,
+    eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR,
+    ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+    eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+    ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+    eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+    ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR,
+    eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
+    eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
+    eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+    ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+    eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
+    eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+    ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
+    eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
+    ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
+    eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
+    eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR,
+    ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR,
+    eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR,
+    eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,
+    ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR,
+    ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR,
+    eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+    eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+    eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
+    eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+    eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+    eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+    eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR,
+    eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+    eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+    eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR,
+    eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR,
+    ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR,
+    eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR,
+    eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR,
+    eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR,
+    ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR,
+    eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR
   };
 
+  VULKAN_HPP_INLINE std::string to_string( StructureType value )
+  {
+    switch ( value )
+    {
+      case StructureType::eApplicationInfo : return "ApplicationInfo";
+      case StructureType::eInstanceCreateInfo : return "InstanceCreateInfo";
+      case StructureType::eDeviceQueueCreateInfo : return "DeviceQueueCreateInfo";
+      case StructureType::eDeviceCreateInfo : return "DeviceCreateInfo";
+      case StructureType::eSubmitInfo : return "SubmitInfo";
+      case StructureType::eMemoryAllocateInfo : return "MemoryAllocateInfo";
+      case StructureType::eMappedMemoryRange : return "MappedMemoryRange";
+      case StructureType::eBindSparseInfo : return "BindSparseInfo";
+      case StructureType::eFenceCreateInfo : return "FenceCreateInfo";
+      case StructureType::eSemaphoreCreateInfo : return "SemaphoreCreateInfo";
+      case StructureType::eEventCreateInfo : return "EventCreateInfo";
+      case StructureType::eQueryPoolCreateInfo : return "QueryPoolCreateInfo";
+      case StructureType::eBufferCreateInfo : return "BufferCreateInfo";
+      case StructureType::eBufferViewCreateInfo : return "BufferViewCreateInfo";
+      case StructureType::eImageCreateInfo : return "ImageCreateInfo";
+      case StructureType::eImageViewCreateInfo : return "ImageViewCreateInfo";
+      case StructureType::eShaderModuleCreateInfo : return "ShaderModuleCreateInfo";
+      case StructureType::ePipelineCacheCreateInfo : return "PipelineCacheCreateInfo";
+      case StructureType::ePipelineShaderStageCreateInfo : return "PipelineShaderStageCreateInfo";
+      case StructureType::ePipelineVertexInputStateCreateInfo : return "PipelineVertexInputStateCreateInfo";
+      case StructureType::ePipelineInputAssemblyStateCreateInfo : return "PipelineInputAssemblyStateCreateInfo";
+      case StructureType::ePipelineTessellationStateCreateInfo : return "PipelineTessellationStateCreateInfo";
+      case StructureType::ePipelineViewportStateCreateInfo : return "PipelineViewportStateCreateInfo";
+      case StructureType::ePipelineRasterizationStateCreateInfo : return "PipelineRasterizationStateCreateInfo";
+      case StructureType::ePipelineMultisampleStateCreateInfo : return "PipelineMultisampleStateCreateInfo";
+      case StructureType::ePipelineDepthStencilStateCreateInfo : return "PipelineDepthStencilStateCreateInfo";
+      case StructureType::ePipelineColorBlendStateCreateInfo : return "PipelineColorBlendStateCreateInfo";
+      case StructureType::ePipelineDynamicStateCreateInfo : return "PipelineDynamicStateCreateInfo";
+      case StructureType::eGraphicsPipelineCreateInfo : return "GraphicsPipelineCreateInfo";
+      case StructureType::eComputePipelineCreateInfo : return "ComputePipelineCreateInfo";
+      case StructureType::ePipelineLayoutCreateInfo : return "PipelineLayoutCreateInfo";
+      case StructureType::eSamplerCreateInfo : return "SamplerCreateInfo";
+      case StructureType::eDescriptorSetLayoutCreateInfo : return "DescriptorSetLayoutCreateInfo";
+      case StructureType::eDescriptorPoolCreateInfo : return "DescriptorPoolCreateInfo";
+      case StructureType::eDescriptorSetAllocateInfo : return "DescriptorSetAllocateInfo";
+      case StructureType::eWriteDescriptorSet : return "WriteDescriptorSet";
+      case StructureType::eCopyDescriptorSet : return "CopyDescriptorSet";
+      case StructureType::eFramebufferCreateInfo : return "FramebufferCreateInfo";
+      case StructureType::eRenderPassCreateInfo : return "RenderPassCreateInfo";
+      case StructureType::eCommandPoolCreateInfo : return "CommandPoolCreateInfo";
+      case StructureType::eCommandBufferAllocateInfo : return "CommandBufferAllocateInfo";
+      case StructureType::eCommandBufferInheritanceInfo : return "CommandBufferInheritanceInfo";
+      case StructureType::eCommandBufferBeginInfo : return "CommandBufferBeginInfo";
+      case StructureType::eRenderPassBeginInfo : return "RenderPassBeginInfo";
+      case StructureType::eBufferMemoryBarrier : return "BufferMemoryBarrier";
+      case StructureType::eImageMemoryBarrier : return "ImageMemoryBarrier";
+      case StructureType::eMemoryBarrier : return "MemoryBarrier";
+      case StructureType::eLoaderInstanceCreateInfo : return "LoaderInstanceCreateInfo";
+      case StructureType::eLoaderDeviceCreateInfo : return "LoaderDeviceCreateInfo";
+      case StructureType::ePhysicalDeviceSubgroupProperties : return "PhysicalDeviceSubgroupProperties";
+      case StructureType::eBindBufferMemoryInfo : return "BindBufferMemoryInfo";
+      case StructureType::eBindImageMemoryInfo : return "BindImageMemoryInfo";
+      case StructureType::ePhysicalDevice16BitStorageFeatures : return "PhysicalDevice16BitStorageFeatures";
+      case StructureType::eMemoryDedicatedRequirements : return "MemoryDedicatedRequirements";
+      case StructureType::eMemoryDedicatedAllocateInfo : return "MemoryDedicatedAllocateInfo";
+      case StructureType::eMemoryAllocateFlagsInfo : return "MemoryAllocateFlagsInfo";
+      case StructureType::eDeviceGroupRenderPassBeginInfo : return "DeviceGroupRenderPassBeginInfo";
+      case StructureType::eDeviceGroupCommandBufferBeginInfo : return "DeviceGroupCommandBufferBeginInfo";
+      case StructureType::eDeviceGroupSubmitInfo : return "DeviceGroupSubmitInfo";
+      case StructureType::eDeviceGroupBindSparseInfo : return "DeviceGroupBindSparseInfo";
+      case StructureType::eBindBufferMemoryDeviceGroupInfo : return "BindBufferMemoryDeviceGroupInfo";
+      case StructureType::eBindImageMemoryDeviceGroupInfo : return "BindImageMemoryDeviceGroupInfo";
+      case StructureType::ePhysicalDeviceGroupProperties : return "PhysicalDeviceGroupProperties";
+      case StructureType::eDeviceGroupDeviceCreateInfo : return "DeviceGroupDeviceCreateInfo";
+      case StructureType::eBufferMemoryRequirementsInfo2 : return "BufferMemoryRequirementsInfo2";
+      case StructureType::eImageMemoryRequirementsInfo2 : return "ImageMemoryRequirementsInfo2";
+      case StructureType::eImageSparseMemoryRequirementsInfo2 : return "ImageSparseMemoryRequirementsInfo2";
+      case StructureType::eMemoryRequirements2 : return "MemoryRequirements2";
+      case StructureType::eSparseImageMemoryRequirements2 : return "SparseImageMemoryRequirements2";
+      case StructureType::ePhysicalDeviceFeatures2 : return "PhysicalDeviceFeatures2";
+      case StructureType::ePhysicalDeviceProperties2 : return "PhysicalDeviceProperties2";
+      case StructureType::eFormatProperties2 : return "FormatProperties2";
+      case StructureType::eImageFormatProperties2 : return "ImageFormatProperties2";
+      case StructureType::ePhysicalDeviceImageFormatInfo2 : return "PhysicalDeviceImageFormatInfo2";
+      case StructureType::eQueueFamilyProperties2 : return "QueueFamilyProperties2";
+      case StructureType::ePhysicalDeviceMemoryProperties2 : return "PhysicalDeviceMemoryProperties2";
+      case StructureType::eSparseImageFormatProperties2 : return "SparseImageFormatProperties2";
+      case StructureType::ePhysicalDeviceSparseImageFormatInfo2 : return "PhysicalDeviceSparseImageFormatInfo2";
+      case StructureType::ePhysicalDevicePointClippingProperties : return "PhysicalDevicePointClippingProperties";
+      case StructureType::eRenderPassInputAttachmentAspectCreateInfo : return "RenderPassInputAttachmentAspectCreateInfo";
+      case StructureType::eImageViewUsageCreateInfo : return "ImageViewUsageCreateInfo";
+      case StructureType::ePipelineTessellationDomainOriginStateCreateInfo : return "PipelineTessellationDomainOriginStateCreateInfo";
+      case StructureType::eRenderPassMultiviewCreateInfo : return "RenderPassMultiviewCreateInfo";
+      case StructureType::ePhysicalDeviceMultiviewFeatures : return "PhysicalDeviceMultiviewFeatures";
+      case StructureType::ePhysicalDeviceMultiviewProperties : return "PhysicalDeviceMultiviewProperties";
+      case StructureType::ePhysicalDeviceVariablePointerFeatures : return "PhysicalDeviceVariablePointerFeatures";
+      case StructureType::eProtectedSubmitInfo : return "ProtectedSubmitInfo";
+      case StructureType::ePhysicalDeviceProtectedMemoryFeatures : return "PhysicalDeviceProtectedMemoryFeatures";
+      case StructureType::ePhysicalDeviceProtectedMemoryProperties : return "PhysicalDeviceProtectedMemoryProperties";
+      case StructureType::eDeviceQueueInfo2 : return "DeviceQueueInfo2";
+      case StructureType::eSamplerYcbcrConversionCreateInfo : return "SamplerYcbcrConversionCreateInfo";
+      case StructureType::eSamplerYcbcrConversionInfo : return "SamplerYcbcrConversionInfo";
+      case StructureType::eBindImagePlaneMemoryInfo : return "BindImagePlaneMemoryInfo";
+      case StructureType::eImagePlaneMemoryRequirementsInfo : return "ImagePlaneMemoryRequirementsInfo";
+      case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures : return "PhysicalDeviceSamplerYcbcrConversionFeatures";
+      case StructureType::eSamplerYcbcrConversionImageFormatProperties : return "SamplerYcbcrConversionImageFormatProperties";
+      case StructureType::eDescriptorUpdateTemplateCreateInfo : return "DescriptorUpdateTemplateCreateInfo";
+      case StructureType::ePhysicalDeviceExternalImageFormatInfo : return "PhysicalDeviceExternalImageFormatInfo";
+      case StructureType::eExternalImageFormatProperties : return "ExternalImageFormatProperties";
+      case StructureType::ePhysicalDeviceExternalBufferInfo : return "PhysicalDeviceExternalBufferInfo";
+      case StructureType::eExternalBufferProperties : return "ExternalBufferProperties";
+      case StructureType::ePhysicalDeviceIdProperties : return "PhysicalDeviceIdProperties";
+      case StructureType::eExternalMemoryBufferCreateInfo : return "ExternalMemoryBufferCreateInfo";
+      case StructureType::eExternalMemoryImageCreateInfo : return "ExternalMemoryImageCreateInfo";
+      case StructureType::eExportMemoryAllocateInfo : return "ExportMemoryAllocateInfo";
+      case StructureType::ePhysicalDeviceExternalFenceInfo : return "PhysicalDeviceExternalFenceInfo";
+      case StructureType::eExternalFenceProperties : return "ExternalFenceProperties";
+      case StructureType::eExportFenceCreateInfo : return "ExportFenceCreateInfo";
+      case StructureType::eExportSemaphoreCreateInfo : return "ExportSemaphoreCreateInfo";
+      case StructureType::ePhysicalDeviceExternalSemaphoreInfo : return "PhysicalDeviceExternalSemaphoreInfo";
+      case StructureType::eExternalSemaphoreProperties : return "ExternalSemaphoreProperties";
+      case StructureType::ePhysicalDeviceMaintenance3Properties : return "PhysicalDeviceMaintenance3Properties";
+      case StructureType::eDescriptorSetLayoutSupport : return "DescriptorSetLayoutSupport";
+      case StructureType::ePhysicalDeviceShaderDrawParameterFeatures : return "PhysicalDeviceShaderDrawParameterFeatures";
+      case StructureType::eSwapchainCreateInfoKHR : return "SwapchainCreateInfoKHR";
+      case StructureType::ePresentInfoKHR : return "PresentInfoKHR";
+      case StructureType::eDeviceGroupPresentCapabilitiesKHR : return "DeviceGroupPresentCapabilitiesKHR";
+      case StructureType::eImageSwapchainCreateInfoKHR : return "ImageSwapchainCreateInfoKHR";
+      case StructureType::eBindImageMemorySwapchainInfoKHR : return "BindImageMemorySwapchainInfoKHR";
+      case StructureType::eAcquireNextImageInfoKHR : return "AcquireNextImageInfoKHR";
+      case StructureType::eDeviceGroupPresentInfoKHR : return "DeviceGroupPresentInfoKHR";
+      case StructureType::eDeviceGroupSwapchainCreateInfoKHR : return "DeviceGroupSwapchainCreateInfoKHR";
+      case StructureType::eDisplayModeCreateInfoKHR : return "DisplayModeCreateInfoKHR";
+      case StructureType::eDisplaySurfaceCreateInfoKHR : return "DisplaySurfaceCreateInfoKHR";
+      case StructureType::eDisplayPresentInfoKHR : return "DisplayPresentInfoKHR";
+      case StructureType::eXlibSurfaceCreateInfoKHR : return "XlibSurfaceCreateInfoKHR";
+      case StructureType::eXcbSurfaceCreateInfoKHR : return "XcbSurfaceCreateInfoKHR";
+      case StructureType::eWaylandSurfaceCreateInfoKHR : return "WaylandSurfaceCreateInfoKHR";
+      case StructureType::eAndroidSurfaceCreateInfoKHR : return "AndroidSurfaceCreateInfoKHR";
+      case StructureType::eWin32SurfaceCreateInfoKHR : return "Win32SurfaceCreateInfoKHR";
+      case StructureType::eDebugReportCallbackCreateInfoEXT : return "DebugReportCallbackCreateInfoEXT";
+      case StructureType::ePipelineRasterizationStateRasterizationOrderAMD : return "PipelineRasterizationStateRasterizationOrderAMD";
+      case StructureType::eDebugMarkerObjectNameInfoEXT : return "DebugMarkerObjectNameInfoEXT";
+      case StructureType::eDebugMarkerObjectTagInfoEXT : return "DebugMarkerObjectTagInfoEXT";
+      case StructureType::eDebugMarkerMarkerInfoEXT : return "DebugMarkerMarkerInfoEXT";
+      case StructureType::eDedicatedAllocationImageCreateInfoNV : return "DedicatedAllocationImageCreateInfoNV";
+      case StructureType::eDedicatedAllocationBufferCreateInfoNV : return "DedicatedAllocationBufferCreateInfoNV";
+      case StructureType::eDedicatedAllocationMemoryAllocateInfoNV : return "DedicatedAllocationMemoryAllocateInfoNV";
+      case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT : return "PhysicalDeviceTransformFeedbackFeaturesEXT";
+      case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT : return "PhysicalDeviceTransformFeedbackPropertiesEXT";
+      case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT";
+      case StructureType::eImageViewHandleInfoNVX : return "ImageViewHandleInfoNVX";
+      case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD";
+      case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV : return "PhysicalDeviceCornerSampledImageFeaturesNV";
+      case StructureType::eExternalMemoryImageCreateInfoNV : return "ExternalMemoryImageCreateInfoNV";
+      case StructureType::eExportMemoryAllocateInfoNV : return "ExportMemoryAllocateInfoNV";
+      case StructureType::eImportMemoryWin32HandleInfoNV : return "ImportMemoryWin32HandleInfoNV";
+      case StructureType::eExportMemoryWin32HandleInfoNV : return "ExportMemoryWin32HandleInfoNV";
+      case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV : return "Win32KeyedMutexAcquireReleaseInfoNV";
+      case StructureType::eValidationFlagsEXT : return "ValidationFlagsEXT";
+      case StructureType::eViSurfaceCreateInfoNN : return "ViSurfaceCreateInfoNN";
+      case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT";
+      case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT : return "PhysicalDeviceAstcDecodeFeaturesEXT";
+      case StructureType::eImportMemoryWin32HandleInfoKHR : return "ImportMemoryWin32HandleInfoKHR";
+      case StructureType::eExportMemoryWin32HandleInfoKHR : return "ExportMemoryWin32HandleInfoKHR";
+      case StructureType::eMemoryWin32HandlePropertiesKHR : return "MemoryWin32HandlePropertiesKHR";
+      case StructureType::eMemoryGetWin32HandleInfoKHR : return "MemoryGetWin32HandleInfoKHR";
+      case StructureType::eImportMemoryFdInfoKHR : return "ImportMemoryFdInfoKHR";
+      case StructureType::eMemoryFdPropertiesKHR : return "MemoryFdPropertiesKHR";
+      case StructureType::eMemoryGetFdInfoKHR : return "MemoryGetFdInfoKHR";
+      case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR : return "Win32KeyedMutexAcquireReleaseInfoKHR";
+      case StructureType::eImportSemaphoreWin32HandleInfoKHR : return "ImportSemaphoreWin32HandleInfoKHR";
+      case StructureType::eExportSemaphoreWin32HandleInfoKHR : return "ExportSemaphoreWin32HandleInfoKHR";
+      case StructureType::eD3D12FenceSubmitInfoKHR : return "D3D12FenceSubmitInfoKHR";
+      case StructureType::eSemaphoreGetWin32HandleInfoKHR : return "SemaphoreGetWin32HandleInfoKHR";
+      case StructureType::eImportSemaphoreFdInfoKHR : return "ImportSemaphoreFdInfoKHR";
+      case StructureType::eSemaphoreGetFdInfoKHR : return "SemaphoreGetFdInfoKHR";
+      case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR : return "PhysicalDevicePushDescriptorPropertiesKHR";
+      case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT";
+      case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT";
+      case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT";
+      case StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR : return "PhysicalDeviceFloat16Int8FeaturesKHR";
+      case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR";
+      case StructureType::eObjectTableCreateInfoNVX : return "ObjectTableCreateInfoNVX";
+      case StructureType::eIndirectCommandsLayoutCreateInfoNVX : return "IndirectCommandsLayoutCreateInfoNVX";
+      case StructureType::eCmdProcessCommandsInfoNVX : return "CmdProcessCommandsInfoNVX";
+      case StructureType::eCmdReserveSpaceForCommandsInfoNVX : return "CmdReserveSpaceForCommandsInfoNVX";
+      case StructureType::eDeviceGeneratedCommandsLimitsNVX : return "DeviceGeneratedCommandsLimitsNVX";
+      case StructureType::eDeviceGeneratedCommandsFeaturesNVX : return "DeviceGeneratedCommandsFeaturesNVX";
+      case StructureType::ePipelineViewportWScalingStateCreateInfoNV : return "PipelineViewportWScalingStateCreateInfoNV";
+      case StructureType::eSurfaceCapabilities2EXT : return "SurfaceCapabilities2EXT";
+      case StructureType::eDisplayPowerInfoEXT : return "DisplayPowerInfoEXT";
+      case StructureType::eDeviceEventInfoEXT : return "DeviceEventInfoEXT";
+      case StructureType::eDisplayEventInfoEXT : return "DisplayEventInfoEXT";
+      case StructureType::eSwapchainCounterCreateInfoEXT : return "SwapchainCounterCreateInfoEXT";
+      case StructureType::ePresentTimesInfoGOOGLE : return "PresentTimesInfoGOOGLE";
+      case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
+      case StructureType::ePipelineViewportSwizzleStateCreateInfoNV : return "PipelineViewportSwizzleStateCreateInfoNV";
+      case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT : return "PhysicalDeviceDiscardRectanglePropertiesEXT";
+      case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT : return "PipelineDiscardRectangleStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT : return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
+      case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT : return "PipelineRasterizationConservativeStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT";
+      case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT";
+      case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT";
+      case StructureType::eAttachmentDescription2KHR : return "AttachmentDescription2KHR";
+      case StructureType::eAttachmentReference2KHR : return "AttachmentReference2KHR";
+      case StructureType::eSubpassDescription2KHR : return "SubpassDescription2KHR";
+      case StructureType::eSubpassDependency2KHR : return "SubpassDependency2KHR";
+      case StructureType::eRenderPassCreateInfo2KHR : return "RenderPassCreateInfo2KHR";
+      case StructureType::eSubpassBeginInfoKHR : return "SubpassBeginInfoKHR";
+      case StructureType::eSubpassEndInfoKHR : return "SubpassEndInfoKHR";
+      case StructureType::eSharedPresentSurfaceCapabilitiesKHR : return "SharedPresentSurfaceCapabilitiesKHR";
+      case StructureType::eImportFenceWin32HandleInfoKHR : return "ImportFenceWin32HandleInfoKHR";
+      case StructureType::eExportFenceWin32HandleInfoKHR : return "ExportFenceWin32HandleInfoKHR";
+      case StructureType::eFenceGetWin32HandleInfoKHR : return "FenceGetWin32HandleInfoKHR";
+      case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR";
+      case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR";
+      case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR";
+      case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR";
+      case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR";
+      case StructureType::eDisplayProperties2KHR : return "DisplayProperties2KHR";
+      case StructureType::eDisplayPlaneProperties2KHR : return "DisplayPlaneProperties2KHR";
+      case StructureType::eDisplayModeProperties2KHR : return "DisplayModeProperties2KHR";
+      case StructureType::eDisplayPlaneInfo2KHR : return "DisplayPlaneInfo2KHR";
+      case StructureType::eDisplayPlaneCapabilities2KHR : return "DisplayPlaneCapabilities2KHR";
+      case StructureType::eIosSurfaceCreateInfoMVK : return "IosSurfaceCreateInfoMVK";
+      case StructureType::eMacosSurfaceCreateInfoMVK : return "MacosSurfaceCreateInfoMVK";
+      case StructureType::eDebugUtilsObjectNameInfoEXT : return "DebugUtilsObjectNameInfoEXT";
+      case StructureType::eDebugUtilsObjectTagInfoEXT : return "DebugUtilsObjectTagInfoEXT";
+      case StructureType::eDebugUtilsLabelEXT : return "DebugUtilsLabelEXT";
+      case StructureType::eDebugUtilsMessengerCallbackDataEXT : return "DebugUtilsMessengerCallbackDataEXT";
+      case StructureType::eDebugUtilsMessengerCreateInfoEXT : return "DebugUtilsMessengerCreateInfoEXT";
+      case StructureType::eAndroidHardwareBufferUsageANDROID : return "AndroidHardwareBufferUsageANDROID";
+      case StructureType::eAndroidHardwareBufferPropertiesANDROID : return "AndroidHardwareBufferPropertiesANDROID";
+      case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID : return "AndroidHardwareBufferFormatPropertiesANDROID";
+      case StructureType::eImportAndroidHardwareBufferInfoANDROID : return "ImportAndroidHardwareBufferInfoANDROID";
+      case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID : return "MemoryGetAndroidHardwareBufferInfoANDROID";
+      case StructureType::eExternalFormatANDROID : return "ExternalFormatANDROID";
+      case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT : return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT";
+      case StructureType::eSamplerReductionModeCreateInfoEXT : return "SamplerReductionModeCreateInfoEXT";
+      case StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT : return "PhysicalDeviceInlineUniformBlockFeaturesEXT";
+      case StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT : return "PhysicalDeviceInlineUniformBlockPropertiesEXT";
+      case StructureType::eWriteDescriptorSetInlineUniformBlockEXT : return "WriteDescriptorSetInlineUniformBlockEXT";
+      case StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT : return "DescriptorPoolInlineUniformBlockCreateInfoEXT";
+      case StructureType::eSampleLocationsInfoEXT : return "SampleLocationsInfoEXT";
+      case StructureType::eRenderPassSampleLocationsBeginInfoEXT : return "RenderPassSampleLocationsBeginInfoEXT";
+      case StructureType::ePipelineSampleLocationsStateCreateInfoEXT : return "PipelineSampleLocationsStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT : return "PhysicalDeviceSampleLocationsPropertiesEXT";
+      case StructureType::eMultisamplePropertiesEXT : return "MultisamplePropertiesEXT";
+      case StructureType::eImageFormatListCreateInfoKHR : return "ImageFormatListCreateInfoKHR";
+      case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT : return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT";
+      case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT : return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT";
+      case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT : return "PipelineColorBlendAdvancedStateCreateInfoEXT";
+      case StructureType::ePipelineCoverageToColorStateCreateInfoNV : return "PipelineCoverageToColorStateCreateInfoNV";
+      case StructureType::ePipelineCoverageModulationStateCreateInfoNV : return "PipelineCoverageModulationStateCreateInfoNV";
+      case StructureType::eDrmFormatModifierPropertiesListEXT : return "DrmFormatModifierPropertiesListEXT";
+      case StructureType::eDrmFormatModifierPropertiesEXT : return "DrmFormatModifierPropertiesEXT";
+      case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT : return "PhysicalDeviceImageDrmFormatModifierInfoEXT";
+      case StructureType::eImageDrmFormatModifierListCreateInfoEXT : return "ImageDrmFormatModifierListCreateInfoEXT";
+      case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT : return "ImageDrmFormatModifierExplicitCreateInfoEXT";
+      case StructureType::eImageDrmFormatModifierPropertiesEXT : return "ImageDrmFormatModifierPropertiesEXT";
+      case StructureType::eValidationCacheCreateInfoEXT : return "ValidationCacheCreateInfoEXT";
+      case StructureType::eShaderModuleValidationCacheCreateInfoEXT : return "ShaderModuleValidationCacheCreateInfoEXT";
+      case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT : return "DescriptorSetLayoutBindingFlagsCreateInfoEXT";
+      case StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT : return "PhysicalDeviceDescriptorIndexingFeaturesEXT";
+      case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT : return "PhysicalDeviceDescriptorIndexingPropertiesEXT";
+      case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT : return "DescriptorSetVariableDescriptorCountAllocateInfoEXT";
+      case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT : return "DescriptorSetVariableDescriptorCountLayoutSupportEXT";
+      case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV";
+      case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV";
+      case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV";
+      case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
+      case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV";
+      case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV";
+      case StructureType::eGeometryNV : return "GeometryNV";
+      case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV";
+      case StructureType::eGeometryAabbNV : return "GeometryAabbNV";
+      case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV";
+      case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV";
+      case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV";
+      case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV";
+      case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV";
+      case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV";
+      case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
+      case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV : return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
+      case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT";
+      case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT";
+      case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT : return "DeviceQueueGlobalPriorityCreateInfoEXT";
+      case StructureType::ePhysicalDevice8BitStorageFeaturesKHR : return "PhysicalDevice8BitStorageFeaturesKHR";
+      case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT";
+      case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
+      case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
+      case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR : return "PhysicalDeviceShaderAtomicInt64FeaturesKHR";
+      case StructureType::eCalibratedTimestampInfoEXT : return "CalibratedTimestampInfoEXT";
+      case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD";
+      case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD";
+      case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
+      case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT : return "PipelineVertexInputDivisorStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT : return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
+      case StructureType::ePhysicalDeviceDriverPropertiesKHR : return "PhysicalDeviceDriverPropertiesKHR";
+      case StructureType::ePhysicalDeviceFloatControlsPropertiesKHR : return "PhysicalDeviceFloatControlsPropertiesKHR";
+      case StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR : return "PhysicalDeviceDepthStencilResolvePropertiesKHR";
+      case StructureType::eSubpassDescriptionDepthStencilResolveKHR : return "SubpassDescriptionDepthStencilResolveKHR";
+      case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV : return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
+      case StructureType::ePhysicalDeviceMeshShaderFeaturesNV : return "PhysicalDeviceMeshShaderFeaturesNV";
+      case StructureType::ePhysicalDeviceMeshShaderPropertiesNV : return "PhysicalDeviceMeshShaderPropertiesNV";
+      case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV : return "PhysicalDeviceFragmentShaderBarycentricFeaturesNV";
+      case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV : return "PhysicalDeviceShaderImageFootprintFeaturesNV";
+      case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV : return "PipelineViewportExclusiveScissorStateCreateInfoNV";
+      case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV";
+      case StructureType::eCheckpointDataNV : return "CheckpointDataNV";
+      case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV";
+      case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR : return "PhysicalDeviceVulkanMemoryModelFeaturesKHR";
+      case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT";
+      case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA : return "ImagepipeSurfaceCreateInfoFUCHSIA";
+      case StructureType::eMetalSurfaceCreateInfoEXT : return "MetalSurfaceCreateInfoEXT";
+      case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT";
+      case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT";
+      case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT";
+      case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT : return "PhysicalDeviceScalarBlockLayoutFeaturesEXT";
+      case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT";
+      case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT";
+      case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT";
+      case StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : return "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV";
+      case StructureType::ePhysicalDeviceBufferAddressFeaturesEXT : return "PhysicalDeviceBufferAddressFeaturesEXT";
+      case StructureType::eBufferDeviceAddressInfoEXT : return "BufferDeviceAddressInfoEXT";
+      case StructureType::eBufferDeviceAddressCreateInfoEXT : return "BufferDeviceAddressCreateInfoEXT";
+      case StructureType::eImageStencilUsageCreateInfoEXT : return "ImageStencilUsageCreateInfoEXT";
+      case StructureType::eValidationFeaturesEXT : return "ValidationFeaturesEXT";
+      case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV : return "PhysicalDeviceCooperativeMatrixFeaturesNV";
+      case StructureType::eCooperativeMatrixPropertiesNV : return "CooperativeMatrixPropertiesNV";
+      case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV : return "PhysicalDeviceCooperativeMatrixPropertiesNV";
+      case StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT : return "PhysicalDeviceYcbcrImageArraysFeaturesEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class SubpassContents
+  {
+    eInline = VK_SUBPASS_CONTENTS_INLINE,
+    eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SubpassContents value )
+  {
+    switch ( value )
+    {
+      case SubpassContents::eInline : return "Inline";
+      case SubpassContents::eSecondaryCommandBuffers : return "SecondaryCommandBuffers";
+      default: return "invalid";
+    }
+  }
+
+  enum class SystemAllocationScope
+  {
+    eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
+    eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
+    eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
+    eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
+    eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SystemAllocationScope value )
+  {
+    switch ( value )
+    {
+      case SystemAllocationScope::eCommand : return "Command";
+      case SystemAllocationScope::eObject : return "Object";
+      case SystemAllocationScope::eCache : return "Cache";
+      case SystemAllocationScope::eDevice : return "Device";
+      case SystemAllocationScope::eInstance : return "Instance";
+      default: return "invalid";
+    }
+  }
+
+  enum class TessellationDomainOrigin
+  {
+    eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+    eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
+    eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR,
+    eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( TessellationDomainOrigin value )
+  {
+    switch ( value )
+    {
+      case TessellationDomainOrigin::eUpperLeft : return "UpperLeft";
+      case TessellationDomainOrigin::eLowerLeft : return "LowerLeft";
+      default: return "invalid";
+    }
+  }
+
+  enum class TimeDomainEXT
+  {
+    eDevice = VK_TIME_DOMAIN_DEVICE_EXT,
+    eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT,
+    eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT,
+    eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( TimeDomainEXT value )
+  {
+    switch ( value )
+    {
+      case TimeDomainEXT::eDevice : return "Device";
+      case TimeDomainEXT::eClockMonotonic : return "ClockMonotonic";
+      case TimeDomainEXT::eClockMonotonicRaw : return "ClockMonotonicRaw";
+      case TimeDomainEXT::eQueryPerformanceCounter : return "QueryPerformanceCounter";
+      default: return "invalid";
+    }
+  }
+
+  enum class ValidationCacheHeaderVersionEXT
+  {
+    eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationCacheHeaderVersionEXT value )
+  {
+    switch ( value )
+    {
+      case ValidationCacheHeaderVersionEXT::eOne : return "One";
+      default: return "invalid";
+    }
+  }
+
+  enum class ValidationCheckEXT
+  {
+    eAll = VK_VALIDATION_CHECK_ALL_EXT,
+    eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationCheckEXT value )
+  {
+    switch ( value )
+    {
+      case ValidationCheckEXT::eAll : return "All";
+      case ValidationCheckEXT::eShaders : return "Shaders";
+      default: return "invalid";
+    }
+  }
+
+  enum class ValidationFeatureDisableEXT
+  {
+    eAll = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT,
+    eShaders = VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT,
+    eThreadSafety = VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT,
+    eApiParameters = VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT,
+    eObjectLifetimes = VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT,
+    eCoreChecks = VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT,
+    eUniqueHandles = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationFeatureDisableEXT value )
+  {
+    switch ( value )
+    {
+      case ValidationFeatureDisableEXT::eAll : return "All";
+      case ValidationFeatureDisableEXT::eShaders : return "Shaders";
+      case ValidationFeatureDisableEXT::eThreadSafety : return "ThreadSafety";
+      case ValidationFeatureDisableEXT::eApiParameters : return "ApiParameters";
+      case ValidationFeatureDisableEXT::eObjectLifetimes : return "ObjectLifetimes";
+      case ValidationFeatureDisableEXT::eCoreChecks : return "CoreChecks";
+      case ValidationFeatureDisableEXT::eUniqueHandles : return "UniqueHandles";
+      default: return "invalid";
+    }
+  }
+
+  enum class ValidationFeatureEnableEXT
+  {
+    eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
+    eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationFeatureEnableEXT value )
+  {
+    switch ( value )
+    {
+      case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted";
+      case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot : return "GpuAssistedReserveBindingSlot";
+      default: return "invalid";
+    }
+  }
+
+  enum class VendorId
+  {
+    eVIV = VK_VENDOR_ID_VIV,
+    eVSI = VK_VENDOR_ID_VSI,
+    eKazan = VK_VENDOR_ID_KAZAN
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VendorId value )
+  {
+    switch ( value )
+    {
+      case VendorId::eVIV : return "VIV";
+      case VendorId::eVSI : return "VSI";
+      case VendorId::eKazan : return "Kazan";
+      default: return "invalid";
+    }
+  }
+
+  enum class VertexInputRate
+  {
+    eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
+    eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VertexInputRate value )
+  {
+    switch ( value )
+    {
+      case VertexInputRate::eVertex : return "Vertex";
+      case VertexInputRate::eInstance : return "Instance";
+      default: return "invalid";
+    }
+  }
+
+  enum class ViewportCoordinateSwizzleNV
+  {
+    ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
+    eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
+    ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
+    eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
+    ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
+    eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
+    ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
+    eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ViewportCoordinateSwizzleNV value )
+  {
+    switch ( value )
+    {
+      case ViewportCoordinateSwizzleNV::ePositiveX : return "PositiveX";
+      case ViewportCoordinateSwizzleNV::eNegativeX : return "NegativeX";
+      case ViewportCoordinateSwizzleNV::ePositiveY : return "PositiveY";
+      case ViewportCoordinateSwizzleNV::eNegativeY : return "NegativeY";
+      case ViewportCoordinateSwizzleNV::ePositiveZ : return "PositiveZ";
+      case ViewportCoordinateSwizzleNV::eNegativeZ : return "NegativeZ";
+      case ViewportCoordinateSwizzleNV::ePositiveW : return "PositiveW";
+      case ViewportCoordinateSwizzleNV::eNegativeW : return "NegativeW";
+      default: return "invalid";
+    }
+  }
+
+  enum class AccessFlagBits
+  {
+    eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+    eIndexRead = VK_ACCESS_INDEX_READ_BIT,
+    eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+    eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
+    eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+    eShaderRead = VK_ACCESS_SHADER_READ_BIT,
+    eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
+    eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+    eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+    eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+    eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+    eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
+    eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
+    eHostRead = VK_ACCESS_HOST_READ_BIT,
+    eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
+    eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
+    eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
+    eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+    eTransformFeedbackCounterReadEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
+    eTransformFeedbackCounterWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+    eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
+    eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
+    eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX,
+    eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
+    eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV,
+    eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV,
+    eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
+    eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AccessFlagBits value )
+  {
+    switch ( value )
+    {
+      case AccessFlagBits::eIndirectCommandRead : return "IndirectCommandRead";
+      case AccessFlagBits::eIndexRead : return "IndexRead";
+      case AccessFlagBits::eVertexAttributeRead : return "VertexAttributeRead";
+      case AccessFlagBits::eUniformRead : return "UniformRead";
+      case AccessFlagBits::eInputAttachmentRead : return "InputAttachmentRead";
+      case AccessFlagBits::eShaderRead : return "ShaderRead";
+      case AccessFlagBits::eShaderWrite : return "ShaderWrite";
+      case AccessFlagBits::eColorAttachmentRead : return "ColorAttachmentRead";
+      case AccessFlagBits::eColorAttachmentWrite : return "ColorAttachmentWrite";
+      case AccessFlagBits::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead";
+      case AccessFlagBits::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite";
+      case AccessFlagBits::eTransferRead : return "TransferRead";
+      case AccessFlagBits::eTransferWrite : return "TransferWrite";
+      case AccessFlagBits::eHostRead : return "HostRead";
+      case AccessFlagBits::eHostWrite : return "HostWrite";
+      case AccessFlagBits::eMemoryRead : return "MemoryRead";
+      case AccessFlagBits::eMemoryWrite : return "MemoryWrite";
+      case AccessFlagBits::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT";
+      case AccessFlagBits::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT";
+      case AccessFlagBits::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT";
+      case AccessFlagBits::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT";
+      case AccessFlagBits::eCommandProcessReadNVX : return "CommandProcessReadNVX";
+      case AccessFlagBits::eCommandProcessWriteNVX : return "CommandProcessWriteNVX";
+      case AccessFlagBits::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT";
+      case AccessFlagBits::eShadingRateImageReadNV : return "ShadingRateImageReadNV";
+      case AccessFlagBits::eAccelerationStructureReadNV : return "AccelerationStructureReadNV";
+      case AccessFlagBits::eAccelerationStructureWriteNV : return "AccelerationStructureWriteNV";
+      case AccessFlagBits::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT";
+      default: return "invalid";
+    }
+  }
+
+  using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
+
+  VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
+  {
+    return AccessFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
+  {
+    return ~( AccessFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<AccessFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV) | VkFlags(AccessFlagBits::eFragmentDensityMapReadEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AccessFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & AccessFlagBits::eIndirectCommandRead ) result += "IndirectCommandRead | ";
+    if ( value & AccessFlagBits::eIndexRead ) result += "IndexRead | ";
+    if ( value & AccessFlagBits::eVertexAttributeRead ) result += "VertexAttributeRead | ";
+    if ( value & AccessFlagBits::eUniformRead ) result += "UniformRead | ";
+    if ( value & AccessFlagBits::eInputAttachmentRead ) result += "InputAttachmentRead | ";
+    if ( value & AccessFlagBits::eShaderRead ) result += "ShaderRead | ";
+    if ( value & AccessFlagBits::eShaderWrite ) result += "ShaderWrite | ";
+    if ( value & AccessFlagBits::eColorAttachmentRead ) result += "ColorAttachmentRead | ";
+    if ( value & AccessFlagBits::eColorAttachmentWrite ) result += "ColorAttachmentWrite | ";
+    if ( value & AccessFlagBits::eDepthStencilAttachmentRead ) result += "DepthStencilAttachmentRead | ";
+    if ( value & AccessFlagBits::eDepthStencilAttachmentWrite ) result += "DepthStencilAttachmentWrite | ";
+    if ( value & AccessFlagBits::eTransferRead ) result += "TransferRead | ";
+    if ( value & AccessFlagBits::eTransferWrite ) result += "TransferWrite | ";
+    if ( value & AccessFlagBits::eHostRead ) result += "HostRead | ";
+    if ( value & AccessFlagBits::eHostWrite ) result += "HostWrite | ";
+    if ( value & AccessFlagBits::eMemoryRead ) result += "MemoryRead | ";
+    if ( value & AccessFlagBits::eMemoryWrite ) result += "MemoryWrite | ";
+    if ( value & AccessFlagBits::eTransformFeedbackWriteEXT ) result += "TransformFeedbackWriteEXT | ";
+    if ( value & AccessFlagBits::eTransformFeedbackCounterReadEXT ) result += "TransformFeedbackCounterReadEXT | ";
+    if ( value & AccessFlagBits::eTransformFeedbackCounterWriteEXT ) result += "TransformFeedbackCounterWriteEXT | ";
+    if ( value & AccessFlagBits::eConditionalRenderingReadEXT ) result += "ConditionalRenderingReadEXT | ";
+    if ( value & AccessFlagBits::eCommandProcessReadNVX ) result += "CommandProcessReadNVX | ";
+    if ( value & AccessFlagBits::eCommandProcessWriteNVX ) result += "CommandProcessWriteNVX | ";
+    if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT ) result += "ColorAttachmentReadNoncoherentEXT | ";
+    if ( value & AccessFlagBits::eShadingRateImageReadNV ) result += "ShadingRateImageReadNV | ";
+    if ( value & AccessFlagBits::eAccelerationStructureReadNV ) result += "AccelerationStructureReadNV | ";
+    if ( value & AccessFlagBits::eAccelerationStructureWriteNV ) result += "AccelerationStructureWriteNV | ";
+    if ( value & AccessFlagBits::eFragmentDensityMapReadEXT ) result += "FragmentDensityMapReadEXT | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
+  }
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  enum class AndroidSurfaceCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  enum class AttachmentDescriptionFlagBits
+  {
+    eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlagBits value )
+  {
+    switch ( value )
+    {
+      case AttachmentDescriptionFlagBits::eMayAlias : return "MayAlias";
+      default: return "invalid";
+    }
+  }
+
+  using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
+
+  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+  {
+    return AttachmentDescriptionFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
+  {
+    return ~( AttachmentDescriptionFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<AttachmentDescriptionFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & AttachmentDescriptionFlagBits::eMayAlias ) result += "MayAlias | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
+  }
+
+  enum class BufferCreateFlagBits
+  {
+    eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
+    eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
+    eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
+    eProtected = VK_BUFFER_CREATE_PROTECTED_BIT,
+    eDeviceAddressCaptureReplayEXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case BufferCreateFlagBits::eSparseBinding : return "SparseBinding";
+      case BufferCreateFlagBits::eSparseResidency : return "SparseResidency";
+      case BufferCreateFlagBits::eSparseAliased : return "SparseAliased";
+      case BufferCreateFlagBits::eProtected : return "Protected";
+      case BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT : return "DeviceAddressCaptureReplayEXT";
+      default: return "invalid";
+    }
+  }
+
+  using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
+
+  VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+  {
+    return BufferCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
+  {
+    return ~( BufferCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<BufferCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected) | VkFlags(BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & BufferCreateFlagBits::eSparseBinding ) result += "SparseBinding | ";
+    if ( value & BufferCreateFlagBits::eSparseResidency ) result += "SparseResidency | ";
+    if ( value & BufferCreateFlagBits::eSparseAliased ) result += "SparseAliased | ";
+    if ( value & BufferCreateFlagBits::eProtected ) result += "Protected | ";
+    if ( value & BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT ) result += "DeviceAddressCaptureReplayEXT | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
+  }
+
+  enum class BufferUsageFlagBits
+  {
+    eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+    eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+    eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
+    eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+    eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+    eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+    eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+    eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+    eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
+    eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT,
+    eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
+    eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
+    eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV,
+    eShaderDeviceAddressEXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferUsageFlagBits value )
+  {
+    switch ( value )
+    {
+      case BufferUsageFlagBits::eTransferSrc : return "TransferSrc";
+      case BufferUsageFlagBits::eTransferDst : return "TransferDst";
+      case BufferUsageFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer";
+      case BufferUsageFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer";
+      case BufferUsageFlagBits::eUniformBuffer : return "UniformBuffer";
+      case BufferUsageFlagBits::eStorageBuffer : return "StorageBuffer";
+      case BufferUsageFlagBits::eIndexBuffer : return "IndexBuffer";
+      case BufferUsageFlagBits::eVertexBuffer : return "VertexBuffer";
+      case BufferUsageFlagBits::eIndirectBuffer : return "IndirectBuffer";
+      case BufferUsageFlagBits::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT";
+      case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT : return "TransformFeedbackCounterBufferEXT";
+      case BufferUsageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
+      case BufferUsageFlagBits::eRayTracingNV : return "RayTracingNV";
+      case BufferUsageFlagBits::eShaderDeviceAddressEXT : return "ShaderDeviceAddressEXT";
+      default: return "invalid";
+    }
+  }
+
+  using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
+
+  VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+  {
+    return BufferUsageFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
+  {
+    return ~( BufferUsageFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<BufferUsageFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV) | VkFlags(BufferUsageFlagBits::eShaderDeviceAddressEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & BufferUsageFlagBits::eTransferSrc ) result += "TransferSrc | ";
+    if ( value & BufferUsageFlagBits::eTransferDst ) result += "TransferDst | ";
+    if ( value & BufferUsageFlagBits::eUniformTexelBuffer ) result += "UniformTexelBuffer | ";
+    if ( value & BufferUsageFlagBits::eStorageTexelBuffer ) result += "StorageTexelBuffer | ";
+    if ( value & BufferUsageFlagBits::eUniformBuffer ) result += "UniformBuffer | ";
+    if ( value & BufferUsageFlagBits::eStorageBuffer ) result += "StorageBuffer | ";
+    if ( value & BufferUsageFlagBits::eIndexBuffer ) result += "IndexBuffer | ";
+    if ( value & BufferUsageFlagBits::eVertexBuffer ) result += "VertexBuffer | ";
+    if ( value & BufferUsageFlagBits::eIndirectBuffer ) result += "IndirectBuffer | ";
+    if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT ) result += "TransformFeedbackBufferEXT | ";
+    if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) result += "TransformFeedbackCounterBufferEXT | ";
+    if ( value & BufferUsageFlagBits::eConditionalRenderingEXT ) result += "ConditionalRenderingEXT | ";
+    if ( value & BufferUsageFlagBits::eRayTracingNV ) result += "RayTracingNV | ";
+    if ( value & BufferUsageFlagBits::eShaderDeviceAddressEXT ) result += "ShaderDeviceAddressEXT | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
+  }
+
+  enum class BufferViewCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class BuildAccelerationStructureFlagBitsNV
+  {
+    eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV,
+    eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV,
+    ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV,
+    ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV,
+    eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagBitsNV value )
+  {
+    switch ( value )
+    {
+      case BuildAccelerationStructureFlagBitsNV::eAllowUpdate : return "AllowUpdate";
+      case BuildAccelerationStructureFlagBitsNV::eAllowCompaction : return "AllowCompaction";
+      case BuildAccelerationStructureFlagBitsNV::ePreferFastTrace : return "PreferFastTrace";
+      case BuildAccelerationStructureFlagBitsNV::ePreferFastBuild : return "PreferFastBuild";
+      case BuildAccelerationStructureFlagBitsNV::eLowMemory : return "LowMemory";
+      default: return "invalid";
+    }
+  }
+
+  using BuildAccelerationStructureFlagsNV = Flags<BuildAccelerationStructureFlagBitsNV, VkBuildAccelerationStructureFlagsNV>;
+
+  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+  {
+    return BuildAccelerationStructureFlagsNV( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits )
+  {
+    return ~( BuildAccelerationStructureFlagsNV( bits ) );
+  }
+
+  template <> struct FlagTraits<BuildAccelerationStructureFlagBitsNV>
+  {
+    enum
+    {
+      allFlags = VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNV::eLowMemory)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsNV value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & BuildAccelerationStructureFlagBitsNV::eAllowUpdate ) result += "AllowUpdate | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::eAllowCompaction ) result += "AllowCompaction | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::ePreferFastTrace ) result += "PreferFastTrace | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::ePreferFastBuild ) result += "PreferFastBuild | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::eLowMemory ) result += "LowMemory | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
+  }
+
+  enum class ColorComponentFlagBits
+  {
+    eR = VK_COLOR_COMPONENT_R_BIT,
+    eG = VK_COLOR_COMPONENT_G_BIT,
+    eB = VK_COLOR_COMPONENT_B_BIT,
+    eA = VK_COLOR_COMPONENT_A_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ColorComponentFlagBits value )
+  {
+    switch ( value )
+    {
+      case ColorComponentFlagBits::eR : return "R";
+      case ColorComponentFlagBits::eG : return "G";
+      case ColorComponentFlagBits::eB : return "B";
+      case ColorComponentFlagBits::eA : return "A";
+      default: return "invalid";
+    }
+  }
+
+  using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
+
+  VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+  {
+    return ColorComponentFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
+  {
+    return ~( ColorComponentFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ColorComponentFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ColorComponentFlagBits::eR ) result += "R | ";
+    if ( value & ColorComponentFlagBits::eG ) result += "G | ";
+    if ( value & ColorComponentFlagBits::eB ) result += "B | ";
+    if ( value & ColorComponentFlagBits::eA ) result += "A | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
+  }
+
+  enum class CommandBufferResetFlagBits
+  {
+    eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlagBits value )
+  {
+    switch ( value )
+    {
+      case CommandBufferResetFlagBits::eReleaseResources : return "ReleaseResources";
+      default: return "invalid";
+    }
+  }
+
+  using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
+
+  VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+  {
+    return CommandBufferResetFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
+  {
+    return ~( CommandBufferResetFlags( bits ) );
+  }