Update Vulkan headers to version 1.3.224

https://github.com/KhronosGroup/Vulkan-Headers
revision 2b55157592bf4c639b76cc16d64acaef565cc4b5
tag v1.3.224

Bug: b/202964266
Change-Id: I7cdca7b4b25af3fa230713684e292eea55c1d4d5
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/67348
Reviewed-by: Nicolas Capens <nicolascapens@google.com>
Presubmit-Ready: Alexis Hétu <sugoi@google.com>
Commit-Queue: Alexis Hétu <sugoi@google.com>
Tested-by: Alexis Hétu <sugoi@google.com>
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index c20a0af..aa38181 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -8,6238 +8,6183 @@
 #ifndef VULKAN_HPP
 #define VULKAN_HPP
 
-#if defined(_MSVC_LANG)
-#	define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
+#if defined( _MSVC_LANG )
+#  define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
 #else
-#	define VULKAN_HPP_CPLUSPLUS __cplusplus
+#  define VULKAN_HPP_CPLUSPLUS __cplusplus
 #endif
 
 #if 201703L < VULKAN_HPP_CPLUSPLUS
-#	define VULKAN_HPP_CPP_VERSION 20
+#  define VULKAN_HPP_CPP_VERSION 20
 #elif 201402L < VULKAN_HPP_CPLUSPLUS
-#	define VULKAN_HPP_CPP_VERSION 17
+#  define VULKAN_HPP_CPP_VERSION 17
 #elif 201103L < VULKAN_HPP_CPLUSPLUS
-#	define VULKAN_HPP_CPP_VERSION 14
+#  define VULKAN_HPP_CPP_VERSION 14
 #elif 199711L < VULKAN_HPP_CPLUSPLUS
-#	define VULKAN_HPP_CPP_VERSION 11
+#  define VULKAN_HPP_CPP_VERSION 11
 #else
-#	error "vulkan.hpp needs at least c++ standard version 11"
+#  error "vulkan.hpp needs at least c++ standard version 11"
 #endif
 
+#include <array>   // ArrayWrapperND
+#include <string>  // std::string
 #include <vulkan/vulkan.h>
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <functional>
-#include <initializer_list>
-#include <sstream>
-#include <string>
-#include <system_error>
-#include <tuple>
-#include <type_traits>
 #if 17 <= VULKAN_HPP_CPP_VERSION
-#	include <string_view>
+#  include <string_view>  // std::string_view
 #endif
 
-#if defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
-#	if !defined(VULKAN_HPP_NO_SMART_HANDLE)
-#		define VULKAN_HPP_NO_SMART_HANDLE
-#	endif
+#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+#    define VULKAN_HPP_NO_SMART_HANDLE
+#  endif
 #else
-#	include <memory>
-#	include <vector>
+#  include <tuple>   // std::tie
+#  include <vector>  // std::vector
 #endif
 
-#if defined(VULKAN_HPP_NO_CONSTRUCTORS)
-#	if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
-#		define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
-#	endif
-#	if !defined(VULKAN_HPP_NO_UNION_CONSTRUCTORS)
-#		define VULKAN_HPP_NO_UNION_CONSTRUCTORS
-#	endif
+#if !defined( VULKAN_HPP_NO_EXCEPTIONS )
+#  include <system_error>  // std::is_error_code_enum
 #endif
 
-#if defined(VULKAN_HPP_NO_SETTERS)
-#	if !defined(VULKAN_HPP_NO_STRUCT_SETTERS)
-#		define VULKAN_HPP_NO_STRUCT_SETTERS
-#	endif
-#	if !defined(VULKAN_HPP_NO_UNION_SETTERS)
-#		define VULKAN_HPP_NO_UNION_SETTERS
-#	endif
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+#  include <algorithm>  // std::transform
 #endif
 
-#if !defined(VULKAN_HPP_ASSERT)
-#	include <cassert>
-#	define VULKAN_HPP_ASSERT assert
+#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
+#  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+#    define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
+#  endif
+#  if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
+#    define VULKAN_HPP_NO_UNION_CONSTRUCTORS
+#  endif
 #endif
 
-#if !defined(VULKAN_HPP_ASSERT_ON_RESULT)
-#	define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
+#if defined( VULKAN_HPP_NO_SETTERS )
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+#    define VULKAN_HPP_NO_STRUCT_SETTERS
+#  endif
+#  if !defined( VULKAN_HPP_NO_UNION_SETTERS )
+#    define VULKAN_HPP_NO_UNION_SETTERS
+#  endif
 #endif
 
-#if !defined(VULKAN_HPP_STATIC_ASSERT)
-#	define VULKAN_HPP_STATIC_ASSERT static_assert
+#if !defined( VULKAN_HPP_ASSERT )
+#  include <cassert>
+#  define VULKAN_HPP_ASSERT assert
 #endif
 
-#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL)
-#	define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
+#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
+#  define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
+#endif
+
+#if !defined( VULKAN_HPP_STATIC_ASSERT )
+#  define VULKAN_HPP_STATIC_ASSERT static_assert
+#endif
+
+#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
+#  define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
 #endif
 
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
-#	if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__)
-#		include <dlfcn.h>
-#	elif defined(_WIN32)
-typedef struct HINSTANCE__ *HINSTANCE;
-#		if defined(_WIN64)
-typedef int64_t(__stdcall *FARPROC)();
-#		else
-typedef int(__stdcall *FARPROC)();
-#		endif
-extern "C" __declspec(dllimport) HINSTANCE __stdcall LoadLibraryA(char const *lpLibFileName);
-extern "C" __declspec(dllimport) int __stdcall FreeLibrary(HINSTANCE hLibModule);
-extern "C" __declspec(dllimport) FARPROC __stdcall GetProcAddress(HINSTANCE hModule, const char *lpProcName);
-#	endif
+#  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
+#    include <dlfcn.h>
+#  elif defined( _WIN32 )
+typedef struct HINSTANCE__ * HINSTANCE;
+#    if defined( _WIN64 )
+typedef int64_t( __stdcall * FARPROC )();
+#    else
+typedef int( __stdcall * FARPROC )();
+#    endif
+extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
+extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
+extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
+#  endif
 #endif
 
-#if !defined(__has_include)
-#	define __has_include(x) false
+#if !defined( __has_include )
+#  define __has_include( x ) false
 #endif
 
-#if(201711 <= __cpp_impl_three_way_comparison) && __has_include(<compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
-#	define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
+#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
+#  define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
 #endif
-#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
-#	include <compare>
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+#  include <compare>
 #endif
 
-#if(201803 <= __cpp_lib_span)
-#	define VULKAN_HPP_SUPPORT_SPAN
-#	include <span>
+#if ( 201803 <= __cpp_lib_span )
+#  define VULKAN_HPP_SUPPORT_SPAN
+#  include <span>
 #endif
 
-static_assert(VK_HEADER_VERSION == 211, "Wrong VK_HEADER_VERSION!");
+static_assert( VK_HEADER_VERSION == 224, "Wrong VK_HEADER_VERSION!" );
 
-// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
+// 32-bit vulkan is not typesafe for non-dispatchable 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(VK_USE_64_BIT_PTR_DEFINES == 1)
-#	if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-#		define VULKAN_HPP_TYPESAFE_CONVERSION
-#	endif
+#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
+#  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.
-#if defined(major)
-#	undef major
+#if defined( major )
+#  undef major
 #endif
-#if defined(minor)
-#	undef minor
+#if defined( minor )
+#  undef minor
 #endif
 
 // Windows defines MemoryBarrier which is deprecated and collides
 // with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
-#if defined(MemoryBarrier)
-#	undef MemoryBarrier
+#if defined( MemoryBarrier )
+#  undef MemoryBarrier
 #endif
 
-#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
-#	if defined(__clang__)
-#		if __has_feature(cxx_unrestricted_unions)
-#			define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-#		endif
-#	elif defined(__GNUC__)
-#		define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-#		if 40600 <= GCC_VERSION
-#			define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-#		endif
-#	elif defined(_MSC_VER)
-#		if 1900 <= _MSC_VER
-#			define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-#		endif
-#	endif
+#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
+#  if defined( __clang__ )
+#    if __has_feature( cxx_unrestricted_unions )
+#      define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#    endif
+#  elif defined( __GNUC__ )
+#    define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
+#    if 40600 <= GCC_VERSION
+#      define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#    endif
+#  elif defined( _MSC_VER )
+#    if 1900 <= _MSC_VER
+#      define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#    endif
+#  endif
 #endif
 
-#if !defined(VULKAN_HPP_INLINE)
-#	if defined(__clang__)
-#		if __has_attribute(always_inline)
-#			define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
-#		else
-#			define VULKAN_HPP_INLINE inline
-#		endif
-#	elif defined(__GNUC__)
-#		define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
-#	elif defined(_MSC_VER)
-#		define VULKAN_HPP_INLINE inline
-#	else
-#		define VULKAN_HPP_INLINE inline
-#	endif
+#if !defined( VULKAN_HPP_INLINE )
+#  if defined( __clang__ )
+#    if __has_attribute( always_inline )
+#      define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+#    else
+#      define VULKAN_HPP_INLINE inline
+#    endif
+#  elif defined( __GNUC__ )
+#    define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+#  elif defined( _MSC_VER )
+#    define VULKAN_HPP_INLINE inline
+#  else
+#    define VULKAN_HPP_INLINE inline
+#  endif
 #endif
 
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-#	define VULKAN_HPP_TYPESAFE_EXPLICIT
+#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+#  define VULKAN_HPP_TYPESAFE_EXPLICIT
 #else
-#	define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
+#  define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
 #endif
 
-#if defined(__cpp_constexpr)
-#	define VULKAN_HPP_CONSTEXPR constexpr
-#	if __cpp_constexpr >= 201304
-#		define VULKAN_HPP_CONSTEXPR_14 constexpr
-#	else
-#		define VULKAN_HPP_CONSTEXPR_14
-#	endif
-#	define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
+#if defined( __cpp_constexpr )
+#  define VULKAN_HPP_CONSTEXPR constexpr
+#  if __cpp_constexpr >= 201304
+#    define VULKAN_HPP_CONSTEXPR_14 constexpr
+#  else
+#    define VULKAN_HPP_CONSTEXPR_14
+#  endif
+#  define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
 #else
-#	define VULKAN_HPP_CONSTEXPR
-#	define VULKAN_HPP_CONSTEXPR_14
-#	define VULKAN_HPP_CONST_OR_CONSTEXPR const
+#  define VULKAN_HPP_CONSTEXPR
+#  define VULKAN_HPP_CONSTEXPR_14
+#  define VULKAN_HPP_CONST_OR_CONSTEXPR const
 #endif
 
-#if !defined(VULKAN_HPP_NOEXCEPT)
-#	if defined(_MSC_VER) && (_MSC_VER <= 1800)
-#		define VULKAN_HPP_NOEXCEPT
-#	else
-#		define VULKAN_HPP_NOEXCEPT noexcept
-#		define VULKAN_HPP_HAS_NOEXCEPT 1
-#		if defined(VULKAN_HPP_NO_EXCEPTIONS)
-#			define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
-#		else
-#			define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-#		endif
-#	endif
+#if !defined( VULKAN_HPP_NOEXCEPT )
+#  if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
+#    define VULKAN_HPP_NOEXCEPT
+#  else
+#    define VULKAN_HPP_NOEXCEPT     noexcept
+#    define VULKAN_HPP_HAS_NOEXCEPT 1
+#    if defined( VULKAN_HPP_NO_EXCEPTIONS )
+#      define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
+#    else
+#      define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+#    endif
+#  endif
 #endif
 
 #if 14 <= VULKAN_HPP_CPP_VERSION
-#	define VULKAN_HPP_DEPRECATED(msg) [[deprecated(msg)]]
+#  define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
 #else
-#	define VULKAN_HPP_DEPRECATED(msg)
+#  define VULKAN_HPP_DEPRECATED( msg )
 #endif
 
-#if(17 <= VULKAN_HPP_CPP_VERSION) && !defined(VULKAN_HPP_NO_NODISCARD_WARNINGS)
-#	define VULKAN_HPP_NODISCARD [[nodiscard]]
-#	if defined(VULKAN_HPP_NO_EXCEPTIONS)
-#		define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
-#	else
-#		define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-#	endif
+#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
+#  define VULKAN_HPP_NODISCARD [[nodiscard]]
+#  if defined( VULKAN_HPP_NO_EXCEPTIONS )
+#    define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
+#  else
+#    define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+#  endif
 #else
-#	define VULKAN_HPP_NODISCARD
-#	define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+#  define VULKAN_HPP_NODISCARD
+#  define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
 #endif
 
-#if !defined(VULKAN_HPP_NAMESPACE)
-#	define VULKAN_HPP_NAMESPACE vk
+#if !defined( VULKAN_HPP_NAMESPACE )
+#  define VULKAN_HPP_NAMESPACE vk
 #endif
 
-#define VULKAN_HPP_STRINGIFY2(text) #text
-#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text)
-#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE)
+#define VULKAN_HPP_STRINGIFY2( text ) #text
+#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
+#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
 
-namespace VULKAN_HPP_NAMESPACE {
-#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
-template<typename T>
-class ArrayProxy
+namespace VULKAN_HPP_NAMESPACE
 {
-public:
-	VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
-	    : m_count(0),
-	      m_ptr(nullptr)
-	{
-	}
+  template <typename T, size_t N>
+  class ArrayWrapper1D : public std::array<T, N>
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
 
-	VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT
-	    : m_count(0),
-	      m_ptr(nullptr)
-	{
-	}
+    VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
 
-	ArrayProxy(T &value) VULKAN_HPP_NOEXCEPT
-	    : m_count(1),
-	      m_ptr(&value)
-	{
-	}
+#if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
+    // on 32 bit compiles, needs overloads on index type int to resolve ambiguities
+    VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::array<T, N>::operator[]( index );
+    }
 
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxy(typename std::remove_const<T>::type &value) VULKAN_HPP_NOEXCEPT
-	    : m_count(1),
-	      m_ptr(&value)
-	{
-	}
-
-	ArrayProxy(uint32_t count, T *ptr) VULKAN_HPP_NOEXCEPT
-	    : m_count(count),
-	      m_ptr(ptr)
-	{
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxy(uint32_t count, typename std::remove_const<T>::type *ptr) VULKAN_HPP_NOEXCEPT
-	    : m_count(count),
-	      m_ptr(ptr)
-	{
-	}
-
-#	if __GNUC__ >= 9
-#		pragma GCC diagnostic push
-#		pragma GCC diagnostic ignored "-Winit-list-lifetime"
-#	endif
-
-	ArrayProxy(std::initializer_list<T> const &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> const &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-	ArrayProxy(std::initializer_list<T> &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-#	if __GNUC__ >= 9
-#		pragma GCC diagnostic pop
-#	endif
-
-	// Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
-	// convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
-	template<typename V,
-	         typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
-	                                 std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
-	ArrayProxy(V const &v) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(v.size())),
-	      m_ptr(v.data())
-	{
-	}
-
-	template<typename V,
-	         typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
-	                                 std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
-	ArrayProxy(V &v) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(v.size())),
-	      m_ptr(v.data())
-	{
-	}
-
-	const T *begin() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr;
-	}
-
-	const T *end() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr + m_count;
-	}
-
-	const T &front() const VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_count && m_ptr);
-		return *m_ptr;
-	}
-
-	const T &back() const VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_count && m_ptr);
-		return *(m_ptr + m_count - 1);
-	}
-
-	bool empty() const VULKAN_HPP_NOEXCEPT
-	{
-		return (m_count == 0);
-	}
-
-	uint32_t size() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_count;
-	}
-
-	T *data() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr;
-	}
-
-private:
-	uint32_t m_count;
-	T *m_ptr;
-};
-
-template<typename T>
-class ArrayProxyNoTemporaries
-{
-public:
-	VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
-	    : m_count(0),
-	      m_ptr(nullptr)
-	{
-	}
-
-	VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries(std::nullptr_t) VULKAN_HPP_NOEXCEPT
-	    : m_count(0),
-	      m_ptr(nullptr)
-	{
-	}
-
-	ArrayProxyNoTemporaries(T &value) VULKAN_HPP_NOEXCEPT
-	    : m_count(1),
-	      m_ptr(&value)
-	{
-	}
-
-	template<typename V>
-	ArrayProxyNoTemporaries(V &&value) = delete;
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxyNoTemporaries(typename std::remove_const<T>::type &value) VULKAN_HPP_NOEXCEPT
-	    : m_count(1),
-	      m_ptr(&value)
-	{
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxyNoTemporaries(typename std::remove_const<T>::type &&value) = delete;
-
-	ArrayProxyNoTemporaries(uint32_t count, T *ptr) VULKAN_HPP_NOEXCEPT
-	    : m_count(count),
-	      m_ptr(ptr)
-	{
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxyNoTemporaries(uint32_t count, typename std::remove_const<T>::type *ptr) VULKAN_HPP_NOEXCEPT
-	    : m_count(count),
-	      m_ptr(ptr)
-	{
-	}
-
-	ArrayProxyNoTemporaries(std::initializer_list<T> const &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-	ArrayProxyNoTemporaries(std::initializer_list<T> const &&list) = delete;
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> const &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> const &&list) = delete;
-
-	ArrayProxyNoTemporaries(std::initializer_list<T> &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-	ArrayProxyNoTemporaries(std::initializer_list<T> &&list) = delete;
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> &list) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(list.size())),
-	      m_ptr(list.begin())
-	{
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
-	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> &&list) = delete;
-
-	// Any type with a .data() return type implicitly convertible to T*, and a // .size() return type implicitly
-	// convertible to size_t.
-	template<typename V,
-	         typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
-	                                 std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
-	ArrayProxyNoTemporaries(V &v) VULKAN_HPP_NOEXCEPT
-	    : m_count(static_cast<uint32_t>(v.size())),
-	      m_ptr(v.data())
-	{
-	}
-
-	const T *begin() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr;
-	}
-
-	const T *end() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr + m_count;
-	}
-
-	const T &front() const VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_count && m_ptr);
-		return *m_ptr;
-	}
-
-	const T &back() const VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_count && m_ptr);
-		return *(m_ptr + m_count - 1);
-	}
-
-	bool empty() const VULKAN_HPP_NOEXCEPT
-	{
-		return (m_count == 0);
-	}
-
-	uint32_t size() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_count;
-	}
-
-	T *data() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr;
-	}
-
-private:
-	uint32_t m_count;
-	T *m_ptr;
-};
+    T & operator[]( int index ) VULKAN_HPP_NOEXCEPT
+    {
+      return std::array<T, N>::operator[]( index );
+    }
 #endif
 
-template<typename T, size_t N>
-class ArrayWrapper1D : public std::array<T, N>
-{
-public:
-	VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
+    operator T const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return this->data();
+    }
 
-	VULKAN_HPP_CONSTEXPR ArrayWrapper1D(std::array<T, N> const &data) VULKAN_HPP_NOEXCEPT : std::array<T, N>(data) {}
+    operator T *() VULKAN_HPP_NOEXCEPT
+    {
+      return this->data();
+    }
 
-#if(VK_USE_64_BIT_PTR_DEFINES == 0)
-	// on 32 bit compiles, needs overloads on index type int to resolve ambiguities
-	VULKAN_HPP_CONSTEXPR T const &operator[](int index) const VULKAN_HPP_NOEXCEPT
-	{
-		return std::array<T, N>::operator[](index);
-	}
-
-	T &operator[](int index) VULKAN_HPP_NOEXCEPT
-	{
-		return std::array<T, N>::operator[](index);
-	}
-#endif
-
-	operator T const *() const VULKAN_HPP_NOEXCEPT
-	{
-		return this->data();
-	}
-
-	operator T *() VULKAN_HPP_NOEXCEPT
-	{
-		return this->data();
-	}
-
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	operator std::string() const
-	{
-		return std::string(this->data());
-	}
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    operator std::string() const
+    {
+      return std::string( this->data() );
+    }
 
 #if 17 <= VULKAN_HPP_CPP_VERSION
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	operator std::string_view() const
-	{
-		return std::string_view(this->data());
-	}
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    operator std::string_view() const
+    {
+      return std::string_view( this->data() );
+    }
 #endif
 
-#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	std::strong_ordering operator<=>(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return *static_cast<std::array<char, N> const *>(this) <=> *static_cast<std::array<char, N> const *>(&rhs);
-	}
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return *static_cast<std::array<char, N> const *>( this ) <=> *static_cast<std::array<char, N> const *>( &rhs );
+    }
 #else
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	bool operator<(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return *static_cast<std::array<char, N> const *>(this) < *static_cast<std::array<char, N> const *>(&rhs);
-	}
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    bool operator<( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return *static_cast<std::array<char, N> const *>( this ) < *static_cast<std::array<char, N> const *>( &rhs );
+    }
 
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	bool operator<=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return *static_cast<std::array<char, N> const *>(this) <= *static_cast<std::array<char, N> const *>(&rhs);
-	}
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    bool operator<=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return *static_cast<std::array<char, N> const *>( this ) <= *static_cast<std::array<char, N> const *>( &rhs );
+    }
 
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	bool operator>(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return *static_cast<std::array<char, N> const *>(this) > *static_cast<std::array<char, N> const *>(&rhs);
-	}
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    bool operator>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return *static_cast<std::array<char, N> const *>( this ) > *static_cast<std::array<char, N> const *>( &rhs );
+    }
 
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	bool operator>=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return *static_cast<std::array<char, N> const *>(this) >= *static_cast<std::array<char, N> const *>(&rhs);
-	}
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    bool operator>=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return *static_cast<std::array<char, N> const *>( this ) >= *static_cast<std::array<char, N> const *>( &rhs );
+    }
 #endif
 
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	bool operator==(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return *static_cast<std::array<char, N> const *>(this) == *static_cast<std::array<char, N> const *>(&rhs);
-	}
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    bool operator==( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return *static_cast<std::array<char, N> const *>( this ) == *static_cast<std::array<char, N> const *>( &rhs );
+    }
 
-	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
-	bool operator!=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return *static_cast<std::array<char, N> const *>(this) != *static_cast<std::array<char, N> const *>(&rhs);
-	}
-};
+    template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+    bool operator!=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return *static_cast<std::array<char, N> const *>( this ) != *static_cast<std::array<char, N> const *>( &rhs );
+    }
+  };
 
-// specialization of relational operators between std::string and arrays of chars
-template<size_t N>
-bool operator<(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
-	return lhs < rhs.data();
-}
+  // specialization of relational operators between std::string and arrays of chars
+  template <size_t N>
+  bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+  {
+    return lhs < rhs.data();
+  }
 
-template<size_t N>
-bool operator<=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
-	return lhs <= rhs.data();
-}
+  template <size_t N>
+  bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+  {
+    return lhs <= rhs.data();
+  }
 
-template<size_t N>
-bool operator>(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
-	return lhs > rhs.data();
-}
+  template <size_t N>
+  bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+  {
+    return lhs > rhs.data();
+  }
 
-template<size_t N>
-bool operator>=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
-	return lhs >= rhs.data();
-}
+  template <size_t N>
+  bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+  {
+    return lhs >= rhs.data();
+  }
 
-template<size_t N>
-bool operator==(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
-	return lhs == rhs.data();
-}
+  template <size_t N>
+  bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+  {
+    return lhs == rhs.data();
+  }
 
-template<size_t N>
-bool operator!=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
-	return lhs != rhs.data();
-}
+  template <size_t N>
+  bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+  {
+    return lhs != rhs.data();
+  }
 
-template<typename T, size_t N, size_t M>
-class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
-{
-public:
-	VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}
+  template <typename T, size_t N, size_t M>
+  class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}
 
-	VULKAN_HPP_CONSTEXPR ArrayWrapper2D(std::array<std::array<T, M>, N> const &data) VULKAN_HPP_NOEXCEPT
-	    : std::array<ArrayWrapper1D<T, M>, N>(*reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>(&data))
-	{
-	}
-};
+    VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
+    {
+    }
+  };
 
-template<typename FlagBitsType>
-struct FlagTraits
-{
-};
+  template <typename FlagBitsType>
+  struct FlagTraits
+  {
+  };
 
-template<typename BitType>
-class Flags
-{
-public:
-	using MaskType = typename std::underlying_type<BitType>::type;
+  template <typename BitType>
+  class Flags
+  {
+  public:
+    using MaskType = typename std::underlying_type<BitType>::type;
 
-	// constructors
-	VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask(0) {}
+    // constructors
+    VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
 
-	VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_NOEXCEPT : m_mask(static_cast<MaskType>(bit)) {}
+    VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
 
-	VULKAN_HPP_CONSTEXPR Flags(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT = default;
+    VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-	VULKAN_HPP_CONSTEXPR explicit Flags(MaskType flags) VULKAN_HPP_NOEXCEPT : m_mask(flags) {}
+    VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
 
-	// relational operators
-#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
-	auto operator<=>(Flags<BitType> const &) const = default;
+    // relational operators
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( Flags<BitType> const & ) const = default;
 #else
-	VULKAN_HPP_CONSTEXPR bool operator<(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return m_mask < rhs.m_mask;
-	}
+    VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return m_mask < rhs.m_mask;
+    }
 
-	VULKAN_HPP_CONSTEXPR bool operator<=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return m_mask <= rhs.m_mask;
-	}
+    VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return m_mask <= rhs.m_mask;
+    }
 
-	VULKAN_HPP_CONSTEXPR bool operator>(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return m_mask > rhs.m_mask;
-	}
+    VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return m_mask > rhs.m_mask;
+    }
 
-	VULKAN_HPP_CONSTEXPR bool operator>=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return m_mask >= rhs.m_mask;
-	}
+    VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return m_mask >= rhs.m_mask;
+    }
 
-	VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return m_mask == rhs.m_mask;
-	}
+    VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return m_mask == rhs.m_mask;
+    }
 
-	VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return m_mask != rhs.m_mask;
-	}
+    VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return m_mask != rhs.m_mask;
+    }
 #endif
 
-	// logical operator
-	VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
-	{
-		return !m_mask;
-	}
+    // logical operator
+    VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
+    {
+      return !m_mask;
+    }
 
-	// bitwise operators
-	VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return Flags<BitType>(m_mask & rhs.m_mask);
-	}
+    // bitwise operators
+    VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return Flags<BitType>( m_mask & rhs.m_mask );
+    }
 
-	VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return Flags<BitType>(m_mask | rhs.m_mask);
-	}
+    VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return Flags<BitType>( m_mask | rhs.m_mask );
+    }
 
-	VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
-	{
-		return Flags<BitType>(m_mask ^ rhs.m_mask);
-	}
+    VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return Flags<BitType>( m_mask ^ rhs.m_mask );
+    }
 
-	VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
-	{
-		return Flags<BitType>(m_mask ^ FlagTraits<BitType>::allFlags);
-	}
+    VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
+    {
+      return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags );
+    }
 
-	// assignment operators
-	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT = default;
+    // assignment operators
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator|=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
-	{
-		m_mask |= rhs.m_mask;
-		return *this;
-	}
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      m_mask |= rhs.m_mask;
+      return *this;
+    }
 
-	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator&=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
-	{
-		m_mask &= rhs.m_mask;
-		return *this;
-	}
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      m_mask &= rhs.m_mask;
+      return *this;
+    }
 
-	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator^=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
-	{
-		m_mask ^= rhs.m_mask;
-		return *this;
-	}
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      m_mask ^= rhs.m_mask;
+      return *this;
+    }
 
-	// cast operators
-	explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
-	{
-		return !!m_mask;
-	}
+    // cast operators
+    explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
+    {
+      return !!m_mask;
+    }
 
-	explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_mask;
-	}
+    explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_mask;
+    }
 
-#if defined(VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC)
-public:
+#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
+  public:
 #else
-private:
+  private:
 #endif
-	MaskType m_mask;
-};
+    MaskType m_mask;
+  };
 
-#if !defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
-// relational operators only needed for pre C++20
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator<(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator>(bit);
-}
+#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+  // relational operators only needed for pre C++20
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator>( bit );
+  }
 
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator<=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator>=(bit);
-}
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator>=( bit );
+  }
 
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator>(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator<(bit);
-}
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator<( bit );
+  }
 
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator>=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator<=(bit);
-}
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator<=( bit );
+  }
 
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator==(bit);
-}
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator==( bit );
+  }
 
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator!=(bit);
-}
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator!=( bit );
+  }
 #endif
 
-// bitwise operators
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator&(bit);
-}
+  // bitwise operators
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator&( bit );
+  }
 
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator|(bit);
-}
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator|( bit );
+  }
 
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
-	return flags.operator^(bit);
-}
+  template <typename BitType>
+  VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  {
+    return flags.operator^( bit );
+  }
 
-template<typename RefType>
-class Optional
-{
-public:
-	Optional(RefType &reference) VULKAN_HPP_NOEXCEPT
-	{
-		m_ptr = &reference;
-	}
-	Optional(RefType *ptr) VULKAN_HPP_NOEXCEPT
-	{
-		m_ptr = ptr;
-	}
-	Optional(std::nullptr_t) VULKAN_HPP_NOEXCEPT
-	{
-		m_ptr = nullptr;
-	}
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+  template <typename T>
+  class ArrayProxy
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
+      : m_count( 0 )
+      , m_ptr( nullptr )
+    {
+    }
 
-	operator RefType *() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr;
-	}
-	RefType const *operator->() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_ptr;
-	}
-	explicit operator bool() const VULKAN_HPP_NOEXCEPT
-	{
-		return !!m_ptr;
-	}
+    VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
+      : m_count( 0 )
+      , m_ptr( nullptr )
+    {
+    }
 
-private:
-	RefType *m_ptr;
-};
+    ArrayProxy( T & value ) VULKAN_HPP_NOEXCEPT
+      : m_count( 1 )
+      , m_ptr( &value )
+    {
+    }
 
-template<typename X, typename Y>
-struct StructExtends
-{
-	enum
-	{
-		value = false
-	};
-};
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
+      : m_count( 1 )
+      , m_ptr( &value )
+    {
+    }
 
-template<typename Type, class...>
-struct IsPartOfStructureChain
-{
-	static const bool valid = false;
-};
+    ArrayProxy( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
+      : m_count( count )
+      , m_ptr( ptr )
+    {
+    }
 
-template<typename Type, typename Head, typename... Tail>
-struct IsPartOfStructureChain<Type, Head, Tail...>
-{
-	static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
-};
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
+      : m_count( count )
+      , m_ptr( ptr )
+    {
+    }
 
-template<size_t Index, typename T, typename... ChainElements>
-struct StructureChainContains
-{
-	static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
-	                          StructureChainContains<Index - 1, T, ChainElements...>::value;
-};
+    template <std::size_t C>
+    ArrayProxy( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+      : m_count( C )
+      , m_ptr( ptr )
+    {
+    }
 
-template<typename T, typename... ChainElements>
-struct StructureChainContains<0, T, ChainElements...>
-{
-	static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
-};
+    template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+      : m_count( C )
+      , m_ptr( ptr )
+    {
+    }
 
-template<size_t Index, typename... ChainElements>
-struct StructureChainValidation
-{
-	using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
-	static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
-	                          (TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value) &&
-	                          StructureChainValidation<Index - 1, ChainElements...>::valid;
-};
+#  if __GNUC__ >= 9
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Winit-list-lifetime"
+#  endif
 
-template<typename... ChainElements>
-struct StructureChainValidation<0, ChainElements...>
-{
-	static const bool valid = true;
-};
+    ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-template<typename... ChainElements>
-class StructureChain : public std::tuple<ChainElements...>
-{
-public:
-	StructureChain() VULKAN_HPP_NOEXCEPT
-	{
-		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
-		link<sizeof...(ChainElements) - 1>();
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-	StructureChain(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(rhs)
-	{
-		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
-		link(&std::get<0>(*this),
-		     &std::get<0>(rhs),
-		     reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
-		     reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
-	}
+    ArrayProxy( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-	StructureChain(StructureChain &&rhs) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(std::forward<std::tuple<ChainElements...>>(rhs))
-	{
-		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
-		link(&std::get<0>(*this),
-		     &std::get<0>(rhs),
-		     reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
-		     reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-	StructureChain(ChainElements const &... elems) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(elems...)
-	{
-		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
-		link<sizeof...(ChainElements) - 1>();
-	}
+#  if __GNUC__ >= 9
+#    pragma GCC diagnostic pop
+#  endif
 
-	StructureChain &operator=(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
-	{
-		std::tuple<ChainElements...>::operator=(rhs);
-		link(&std::get<0>(*this),
-		     &std::get<0>(rhs),
-		     reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
-		     reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
-		return *this;
-	}
+    // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
+    // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
+    template <typename V,
+              typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+                                      std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
+    ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( v.size() ) )
+      , m_ptr( v.data() )
+    {
+    }
 
-	StructureChain &operator=(StructureChain &&rhs) = delete;
+    template <typename V,
+              typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+                                      std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
+    ArrayProxy( V & v ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( v.size() ) )
+      , m_ptr( v.data() )
+    {
+    }
 
-	template<typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
-	T &get() VULKAN_HPP_NOEXCEPT
-	{
-		return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(static_cast<std::tuple<ChainElements...> &>(*this));
-	}
+    const T * begin() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr;
+    }
 
-	template<typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
-	T const &get() const VULKAN_HPP_NOEXCEPT
-	{
-		return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(static_cast<std::tuple<ChainElements...> const &>(*this));
-	}
+    const T * end() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr + m_count;
+    }
 
-	template<typename T0, typename T1, typename... Ts>
-	std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
-	{
-		return std::tie(get<T0>(), get<T1>(), get<Ts>()...);
-	}
+    const T & front() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_count && m_ptr );
+      return *m_ptr;
+    }
 
-	template<typename T0, typename T1, typename... Ts>
-	std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
-	{
-		return std::tie(get<T0>(), get<T1>(), get<Ts>()...);
-	}
+    const T & back() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_count && m_ptr );
+      return *( m_ptr + m_count - 1 );
+    }
 
-	template<typename ClassType, size_t Which = 0>
-	typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && (Which == 0), bool>::type
-	isLinked() const VULKAN_HPP_NOEXCEPT
-	{
-		return true;
-	}
+    bool empty() const VULKAN_HPP_NOEXCEPT
+    {
+      return ( m_count == 0 );
+    }
 
-	template<typename ClassType, size_t Which = 0>
-	typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), bool>::type
-	isLinked() const VULKAN_HPP_NOEXCEPT
-	{
-		static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!");
-		return isLinked(reinterpret_cast<VkBaseInStructure const *>(&get<ClassType, Which>()));
-	}
+    uint32_t size() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_count;
+    }
 
-	template<typename ClassType, size_t Which = 0>
-	typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), void>::type
-	relink() VULKAN_HPP_NOEXCEPT
-	{
-		static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!");
-		auto pNext = reinterpret_cast<VkBaseInStructure *>(&get<ClassType, Which>());
-		VULKAN_HPP_ASSERT(!isLinked(pNext));
-		auto &headElement = std::get<0>(static_cast<std::tuple<ChainElements...> &>(*this));
-		pNext->pNext = reinterpret_cast<VkBaseInStructure const *>(headElement.pNext);
-		headElement.pNext = pNext;
-	}
+    T * data() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr;
+    }
 
-	template<typename ClassType, size_t Which = 0>
-	typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), void>::type
-	unlink() VULKAN_HPP_NOEXCEPT
-	{
-		static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!");
-		unlink(reinterpret_cast<VkBaseOutStructure const *>(&get<ClassType, Which>()));
-	}
+  private:
+    uint32_t m_count;
+    T *      m_ptr;
+  };
 
-private:
-	template<int Index, typename T, int Which, typename, class First, class... Types>
-	struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
-	{
-	};
+  template <typename T>
+  class ArrayProxyNoTemporaries
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
+      : m_count( 0 )
+      , m_ptr( nullptr )
+    {
+    }
 
-	template<int Index, typename T, int Which, class First, class... Types>
-	struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
-	    : ChainElementIndex<Index + 1, T, Which, void, Types...>
-	{
-	};
+    VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
+      : m_count( 0 )
+      , m_ptr( nullptr )
+    {
+    }
 
-	template<int Index, typename T, int Which, class First, class... Types>
-	struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
-	    : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
-	{
-	};
+    ArrayProxyNoTemporaries( T & value ) VULKAN_HPP_NOEXCEPT
+      : m_count( 1 )
+      , m_ptr( &value )
+    {
+    }
 
-	template<int Index, typename T, class First, class... Types>
-	struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
-	    : std::integral_constant<int, Index>
-	{
-	};
+    template <typename V>
+    ArrayProxyNoTemporaries( V && value ) = delete;
 
-	bool isLinked(VkBaseInStructure const *pNext) const VULKAN_HPP_NOEXCEPT
-	{
-		VkBaseInStructure const *elementPtr =
-		    reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(static_cast<std::tuple<ChainElements...> const &>(*this)));
-		while(elementPtr)
-		{
-			if(elementPtr->pNext == pNext)
-			{
-				return true;
-			}
-			elementPtr = elementPtr->pNext;
-		}
-		return false;
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
+      : m_count( 1 )
+      , m_ptr( &value )
+    {
+    }
 
-	template<size_t Index>
-	typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
-	{
-		auto &x = std::get<Index - 1>(static_cast<std::tuple<ChainElements...> &>(*this));
-		x.pNext = &std::get<Index>(static_cast<std::tuple<ChainElements...> &>(*this));
-		link<Index - 1>();
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( typename std::remove_const<T>::type && value ) = delete;
 
-	template<size_t Index>
-	typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
-	{
-	}
+    ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
+      : m_count( count )
+      , m_ptr( ptr )
+    {
+    }
 
-	void link(void *dstBase, void const *srcBase, VkBaseOutStructure *dst, VkBaseInStructure const *src)
-	{
-		while(src->pNext)
-		{
-			std::ptrdiff_t offset = reinterpret_cast<char const *>(src->pNext) - reinterpret_cast<char const *>(srcBase);
-			dst->pNext = reinterpret_cast<VkBaseOutStructure *>(reinterpret_cast<char *>(dstBase) + offset);
-			dst = dst->pNext;
-			src = src->pNext;
-		}
-		dst->pNext = nullptr;
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
+      : m_count( count )
+      , m_ptr( ptr )
+    {
+    }
 
-	void unlink(VkBaseOutStructure const *pNext) VULKAN_HPP_NOEXCEPT
-	{
-		VkBaseOutStructure *elementPtr = reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(static_cast<std::tuple<ChainElements...> &>(*this)));
-		while(elementPtr && (elementPtr->pNext != pNext))
-		{
-			elementPtr = elementPtr->pNext;
-		}
-		if(elementPtr)
-		{
-			elementPtr->pNext = pNext->pNext;
-		}
-		else
-		{
-			VULKAN_HPP_ASSERT(false);  // fires, if the ClassType member has already been unlinked !
-		}
-	}
-};
+    template <std::size_t C>
+    ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+      : m_count( C )
+      , m_ptr( ptr )
+    {
+    }
 
-#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
-template<typename Type, typename Dispatch>
-class UniqueHandleTraits;
+    template <std::size_t C>
+    ArrayProxyNoTemporaries( T( &&ptr )[C] ) = delete;
 
-template<typename Type, typename Dispatch>
-class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
-{
-private:
-	using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
+    template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+      : m_count( C )
+      , m_ptr( ptr )
+    {
+    }
 
-public:
-	using element_type = Type;
+    template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( typename std::remove_const<T>::type( &&ptr )[C] ) = delete;
 
-	UniqueHandle()
-	    : Deleter()
-	    , m_value()
-	{}
+    ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-	explicit UniqueHandle(Type const &value, Deleter const &deleter = Deleter()) VULKAN_HPP_NOEXCEPT
-	    : Deleter(deleter),
-	      m_value(value)
-	{
-	}
+    ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete;
 
-	UniqueHandle(UniqueHandle const &) = delete;
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-	UniqueHandle(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
-	    : Deleter(std::move(static_cast<Deleter &>(other))),
-	      m_value(other.release())
-	{
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete;
 
-	~UniqueHandle() VULKAN_HPP_NOEXCEPT
-	{
-		if(m_value)
-		{
-			this->destroy(m_value);
-		}
-	}
+    ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-	UniqueHandle &operator=(UniqueHandle const &) = delete;
+    ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete;
 
-	UniqueHandle &operator=(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
-	{
-		reset(other.release());
-		*static_cast<Deleter *>(this) = std::move(static_cast<Deleter &>(other));
-		return *this;
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( list.size() ) )
+      , m_ptr( list.begin() )
+    {
+    }
 
-	explicit operator bool() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_value.operator bool();
-	}
+    template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete;
 
-	Type const *operator->() const VULKAN_HPP_NOEXCEPT
-	{
-		return &m_value;
-	}
+    // Any type with a .data() return type implicitly convertible to T*, and a // .size() return type implicitly
+    // convertible to size_t.
+    template <typename V,
+              typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+                                      std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
+    ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( v.size() ) )
+      , m_ptr( v.data() )
+    {
+    }
 
-	Type *operator->() VULKAN_HPP_NOEXCEPT
-	{
-		return &m_value;
-	}
+    const T * begin() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr;
+    }
 
-	Type const &operator*() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_value;
-	}
+    const T * end() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr + m_count;
+    }
 
-	Type &operator*() VULKAN_HPP_NOEXCEPT
-	{
-		return m_value;
-	}
+    const T & front() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_count && m_ptr );
+      return *m_ptr;
+    }
 
-	const Type &get() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_value;
-	}
+    const T & back() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_count && m_ptr );
+      return *( m_ptr + m_count - 1 );
+    }
 
-	Type &get() VULKAN_HPP_NOEXCEPT
-	{
-		return m_value;
-	}
+    bool empty() const VULKAN_HPP_NOEXCEPT
+    {
+      return ( m_count == 0 );
+    }
 
-	void reset(Type const &value = Type()) VULKAN_HPP_NOEXCEPT
-	{
-		if(m_value != value)
-		{
-			if(m_value)
-			{
-				this->destroy(m_value);
-			}
-			m_value = value;
-		}
-	}
+    uint32_t size() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_count;
+    }
 
-	Type release() VULKAN_HPP_NOEXCEPT
-	{
-		Type value = m_value;
-		m_value = nullptr;
-		return value;
-	}
+    T * data() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr;
+    }
 
-	void swap(UniqueHandle<Type, Dispatch> &rhs) VULKAN_HPP_NOEXCEPT
-	{
-		std::swap(m_value, rhs.m_value);
-		std::swap(static_cast<Deleter &>(*this), static_cast<Deleter &>(rhs));
-	}
+  private:
+    uint32_t m_count;
+    T *      m_ptr;
+  };
 
-private:
-	Type m_value;
-};
+  template <typename RefType>
+  class Optional
+  {
+  public:
+    Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT
+    {
+      m_ptr = &reference;
+    }
+    Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT
+    {
+      m_ptr = ptr;
+    }
+    Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
+    {
+      m_ptr = nullptr;
+    }
 
-template<typename UniqueType>
-VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw(std::vector<UniqueType> const &handles)
-{
-	std::vector<typename UniqueType::element_type> newBuffer(handles.size());
-	std::transform(handles.begin(), handles.end(), newBuffer.begin(), [](UniqueType const &handle) { return handle.get(); });
-	return newBuffer;
-}
+    operator RefType *() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr;
+    }
+    RefType const * operator->() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_ptr;
+    }
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT
+    {
+      return !!m_ptr;
+    }
 
-template<typename Type, typename Dispatch>
-VULKAN_HPP_INLINE void swap(UniqueHandle<Type, Dispatch> &lhs, UniqueHandle<Type, Dispatch> &rhs) VULKAN_HPP_NOEXCEPT
-{
-	lhs.swap(rhs);
-}
+  private:
+    RefType * m_ptr;
+  };
+
+  template <typename X, typename Y>
+  struct StructExtends
+  {
+    enum
+    {
+      value = false
+    };
+  };
+
+  template <typename Type, class...>
+  struct IsPartOfStructureChain
+  {
+    static const bool valid = false;
+  };
+
+  template <typename Type, typename Head, typename... Tail>
+  struct IsPartOfStructureChain<Type, Head, Tail...>
+  {
+    static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
+  };
+
+  template <size_t Index, typename T, typename... ChainElements>
+  struct StructureChainContains
+  {
+    static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
+                              StructureChainContains<Index - 1, T, ChainElements...>::value;
+  };
+
+  template <typename T, typename... ChainElements>
+  struct StructureChainContains<0, T, ChainElements...>
+  {
+    static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
+  };
+
+  template <size_t Index, typename... ChainElements>
+  struct StructureChainValidation
+  {
+    using TestType          = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
+    static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
+                              ( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
+                              StructureChainValidation<Index - 1, ChainElements...>::valid;
+  };
+
+  template <typename... ChainElements>
+  struct StructureChainValidation<0, ChainElements...>
+  {
+    static const bool valid = true;
+  };
+
+  template <typename... ChainElements>
+  class StructureChain : public std::tuple<ChainElements...>
+  {
+  public:
+    StructureChain() VULKAN_HPP_NOEXCEPT
+    {
+      static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+      link<sizeof...( ChainElements ) - 1>();
+    }
+
+    StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
+    {
+      static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+      link( &std::get<0>( *this ),
+            &std::get<0>( rhs ),
+            reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
+            reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
+    }
+
+    StructureChain( StructureChain && rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( std::forward<std::tuple<ChainElements...>>( rhs ) )
+    {
+      static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+      link( &std::get<0>( *this ),
+            &std::get<0>( rhs ),
+            reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
+            reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
+    }
+
+    StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
+    {
+      static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+      link<sizeof...( ChainElements ) - 1>();
+    }
+
+    StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      std::tuple<ChainElements...>::operator=( rhs );
+      link( &std::get<0>( *this ),
+            &std::get<0>( rhs ),
+            reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
+            reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
+      return *this;
+    }
+
+    StructureChain & operator=( StructureChain && rhs ) = delete;
+
+    template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
+    T & get() VULKAN_HPP_NOEXCEPT
+    {
+      return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+    }
+
+    template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
+    T const & get() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> const &>( *this ) );
+    }
+
+    template <typename T0, typename T1, typename... Ts>
+    std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
+    }
+
+    template <typename T0, typename T1, typename... Ts>
+    std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
+    }
+
+    template <typename ClassType, size_t Which = 0>
+    typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
+      isLinked() const VULKAN_HPP_NOEXCEPT
+    {
+      return true;
+    }
+
+    template <typename ClassType, size_t Which = 0>
+    typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
+      isLinked() const VULKAN_HPP_NOEXCEPT
+    {
+      static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
+      return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
+    }
+
+    template <typename ClassType, size_t Which = 0>
+    typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
+      relink() VULKAN_HPP_NOEXCEPT
+    {
+      static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
+      auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
+      VULKAN_HPP_ASSERT( !isLinked( pNext ) );
+      auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+      pNext->pNext       = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext );
+      headElement.pNext  = pNext;
+    }
+
+    template <typename ClassType, size_t Which = 0>
+    typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
+      unlink() VULKAN_HPP_NOEXCEPT
+    {
+      static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
+      unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
+    }
+
+  private:
+    template <int Index, typename T, int Which, typename, class First, class... Types>
+    struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
+    {
+    };
+
+    template <int Index, typename T, int Which, class First, class... Types>
+    struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
+      : ChainElementIndex<Index + 1, T, Which, void, Types...>
+    {
+    };
+
+    template <int Index, typename T, int Which, class First, class... Types>
+    struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
+      : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
+    {
+    };
+
+    template <int Index, typename T, class First, class... Types>
+    struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
+      : std::integral_constant<int, Index>
+    {
+    };
+
+    bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT
+    {
+      VkBaseInStructure const * elementPtr =
+        reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) );
+      while ( elementPtr )
+      {
+        if ( elementPtr->pNext == pNext )
+        {
+          return true;
+        }
+        elementPtr = elementPtr->pNext;
+      }
+      return false;
+    }
+
+    template <size_t Index>
+    typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
+    {
+      auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+      x.pNext  = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+      link<Index - 1>();
+    }
+
+    template <size_t Index>
+    typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
+    {
+    }
+
+    void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src )
+    {
+      while ( src->pNext )
+      {
+        std::ptrdiff_t offset = reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase );
+        dst->pNext            = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset );
+        dst                   = dst->pNext;
+        src                   = src->pNext;
+      }
+      dst->pNext = nullptr;
+    }
+
+    void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT
+    {
+      VkBaseOutStructure * elementPtr = reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) );
+      while ( elementPtr && ( elementPtr->pNext != pNext ) )
+      {
+        elementPtr = elementPtr->pNext;
+      }
+      if ( elementPtr )
+      {
+        elementPtr->pNext = pNext->pNext;
+      }
+      else
+      {
+        VULKAN_HPP_ASSERT( false );  // fires, if the ClassType member has already been unlinked !
+      }
+    }
+  };
+
+#  if !defined( 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:
+    using element_type = Type;
+
+    UniqueHandle() : Deleter(), m_value() {}
+
+    explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
+      : Deleter( deleter )
+      , m_value( value )
+    {
+    }
+
+    UniqueHandle( UniqueHandle const & ) = delete;
+
+    UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
+      : Deleter( std::move( static_cast<Deleter &>( other ) ) )
+      , m_value( other.release() )
+    {
+    }
+
+    ~UniqueHandle() VULKAN_HPP_NOEXCEPT
+    {
+      if ( m_value )
+      {
+        this->destroy( m_value );
+      }
+    }
+
+    UniqueHandle & operator=( UniqueHandle const & ) = delete;
+
+    UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
+    {
+      reset( other.release() );
+      *static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) );
+      return *this;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_value.operator bool();
+    }
+
+    Type const * operator->() const VULKAN_HPP_NOEXCEPT
+    {
+      return &m_value;
+    }
+
+    Type * operator->() VULKAN_HPP_NOEXCEPT
+    {
+      return &m_value;
+    }
+
+    Type const & operator*() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_value;
+    }
+
+    Type & operator*() VULKAN_HPP_NOEXCEPT
+    {
+      return m_value;
+    }
+
+    const Type & get() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_value;
+    }
+
+    Type & get() VULKAN_HPP_NOEXCEPT
+    {
+      return m_value;
+    }
+
+    void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT
+    {
+      if ( m_value != value )
+      {
+        if ( m_value )
+        {
+          this->destroy( m_value );
+        }
+        m_value = value;
+      }
+    }
+
+    Type release() VULKAN_HPP_NOEXCEPT
+    {
+      Type value = m_value;
+      m_value    = nullptr;
+      return value;
+    }
+
+    void swap( UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      std::swap( m_value, rhs.m_value );
+      std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) );
+    }
+
+  private:
+    Type m_value;
+  };
+
+  template <typename UniqueType>
+  VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw( std::vector<UniqueType> const & handles )
+  {
+    std::vector<typename UniqueType::element_type> newBuffer( handles.size() );
+    std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } );
+    return newBuffer;
+  }
+
+  template <typename Type, typename Dispatch>
+  VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs, UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
+  {
+    lhs.swap( rhs );
+  }
+#  endif
+#endif  // VULKAN_HPP_DISABLE_ENHANCED_MODE
+
+  class DispatchLoaderBase
+  {
+  public:
+    DispatchLoaderBase() = default;
+    DispatchLoaderBase( std::nullptr_t )
+#if !defined( NDEBUG )
+      : m_valid( false )
+#endif
+    {
+    }
+
+#if !defined( NDEBUG )
+    size_t getVkHeaderVersion() const
+    {
+      VULKAN_HPP_ASSERT( m_valid );
+      return vkHeaderVersion;
+    }
+
+  private:
+    size_t vkHeaderVersion = VK_HEADER_VERSION;
+    bool   m_valid         = true;
+#endif
+  };
+
+#if !defined( VK_NO_PROTOTYPES )
+  class DispatchLoaderStatic : public DispatchLoaderBase
+  {
+  public:
+    //=== VK_VERSION_1_0 ===
+
+    VkResult
+      vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
+    }
+
+    void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyInstance( instance, pAllocator );
+    }
+
+    VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
+    }
+
+    void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
+    }
+
+    void
+      vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice          physicalDevice,
+                                                       VkFormat                  format,
+                                                       VkImageType               type,
+                                                       VkImageTiling             tiling,
+                                                       VkImageUsageFlags         usage,
+                                                       VkImageCreateFlags        flags,
+                                                       VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice          physicalDevice,
+                                                   uint32_t *                pQueueFamilyPropertyCount,
+                                                   VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
+    }
+
+    PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetInstanceProcAddr( instance, pName );
+    }
+
+    PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceProcAddr( device, pName );
+    }
+
+    VkResult vkCreateDevice( VkPhysicalDevice              physicalDevice,
+                             const VkDeviceCreateInfo *    pCreateInfo,
+                             const VkAllocationCallbacks * pAllocator,
+                             VkDevice *                    pDevice ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
+    }
+
+    void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDevice( device, pAllocator );
+    }
+
+    VkResult vkEnumerateInstanceExtensionProperties( const char *            pLayerName,
+                                                     uint32_t *              pPropertyCount,
+                                                     VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice        physicalDevice,
+                                                   const char *            pLayerName,
+                                                   uint32_t *              pPropertyCount,
+                                                   VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
+    }
+
+    VkResult
+      vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
+    }
+
+    VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
+    }
+
+    VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueWaitIdle( queue );
+    }
+
+    VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDeviceWaitIdle( device );
+    }
+
+    VkResult vkAllocateMemory( VkDevice                      device,
+                               const VkMemoryAllocateInfo *  pAllocateInfo,
+                               const VkAllocationCallbacks * pAllocator,
+                               VkDeviceMemory *              pMemory ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
+    }
+
+    void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkFreeMemory( device, memory, pAllocator );
+    }
+
+    VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkMapMemory( device, memory, offset, size, flags, ppData );
+    }
+
+    void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUnmapMemory( device, memory );
+    }
+
+    VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+    }
+
+    VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+    }
+
+    void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
+    }
+
+    VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
+    }
+
+    VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindImageMemory( device, image, memory, memoryOffset );
+    }
+
+    void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
+    }
+
+    void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements( VkDevice                          device,
+                                             VkImage                           image,
+                                             uint32_t *                        pSparseMemoryRequirementCount,
+                                             VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice                physicalDevice,
+                                                         VkFormat                        format,
+                                                         VkImageType                     type,
+                                                         VkSampleCountFlagBits           samples,
+                                                         VkImageUsageFlags               usage,
+                                                         VkImageTiling                   tiling,
+                                                         uint32_t *                      pPropertyCount,
+                                                         VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
+    }
+
+    VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
+    }
+
+    VkResult vkCreateFence( VkDevice                      device,
+                            const VkFenceCreateInfo *     pCreateInfo,
+                            const VkAllocationCallbacks * pAllocator,
+                            VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
+    }
+
+    void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyFence( device, fence, pAllocator );
+    }
+
+    VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetFences( device, fenceCount, pFences );
+    }
+
+    VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetFenceStatus( device, fence );
+    }
+
+    VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
+    }
+
+    VkResult vkCreateSemaphore( VkDevice                      device,
+                                const VkSemaphoreCreateInfo * pCreateInfo,
+                                const VkAllocationCallbacks * pAllocator,
+                                VkSemaphore *                 pSemaphore ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
+    }
+
+    void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroySemaphore( device, semaphore, pAllocator );
+    }
+
+    VkResult vkCreateEvent( VkDevice                      device,
+                            const VkEventCreateInfo *     pCreateInfo,
+                            const VkAllocationCallbacks * pAllocator,
+                            VkEvent *                     pEvent ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
+    }
+
+    void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyEvent( device, event, pAllocator );
+    }
+
+    VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetEventStatus( device, event );
+    }
+
+    VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetEvent( device, event );
+    }
+
+    VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetEvent( device, event );
+    }
+
+    VkResult vkCreateQueryPool( VkDevice                      device,
+                                const VkQueryPoolCreateInfo * pCreateInfo,
+                                const VkAllocationCallbacks * pAllocator,
+                                VkQueryPool *                 pQueryPool ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
+    }
+
+    void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyQueryPool( device, queryPool, pAllocator );
+    }
+
+    VkResult vkGetQueryPoolResults( VkDevice           device,
+                                    VkQueryPool        queryPool,
+                                    uint32_t           firstQuery,
+                                    uint32_t           queryCount,
+                                    size_t             dataSize,
+                                    void *             pData,
+                                    VkDeviceSize       stride,
+                                    VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
+    }
+
+    VkResult vkCreateBuffer( VkDevice                      device,
+                             const VkBufferCreateInfo *    pCreateInfo,
+                             const VkAllocationCallbacks * pAllocator,
+                             VkBuffer *                    pBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
+    }
+
+    void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyBuffer( device, buffer, pAllocator );
+    }
+
+    VkResult vkCreateBufferView( VkDevice                       device,
+                                 const VkBufferViewCreateInfo * pCreateInfo,
+                                 const VkAllocationCallbacks *  pAllocator,
+                                 VkBufferView *                 pView ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
+    }
+
+    void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyBufferView( device, bufferView, pAllocator );
+    }
+
+    VkResult vkCreateImage( VkDevice                      device,
+                            const VkImageCreateInfo *     pCreateInfo,
+                            const VkAllocationCallbacks * pAllocator,
+                            VkImage *                     pImage ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
+    }
+
+    void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyImage( device, image, pAllocator );
+    }
+
+    void vkGetImageSubresourceLayout( VkDevice                   device,
+                                      VkImage                    image,
+                                      const VkImageSubresource * pSubresource,
+                                      VkSubresourceLayout *      pLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
+    }
+
+    VkResult vkCreateImageView( VkDevice                      device,
+                                const VkImageViewCreateInfo * pCreateInfo,
+                                const VkAllocationCallbacks * pAllocator,
+                                VkImageView *                 pView ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
+    }
+
+    void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyImageView( device, imageView, pAllocator );
+    }
+
+    VkResult vkCreateShaderModule( VkDevice                         device,
+                                   const VkShaderModuleCreateInfo * pCreateInfo,
+                                   const VkAllocationCallbacks *    pAllocator,
+                                   VkShaderModule *                 pShaderModule ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
+    }
+
+    void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
+    }
+
+    VkResult vkCreatePipelineCache( VkDevice                          device,
+                                    const VkPipelineCacheCreateInfo * pCreateInfo,
+                                    const VkAllocationCallbacks *     pAllocator,
+                                    VkPipelineCache *                 pPipelineCache ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
+    }
+
+    void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
+    }
+
+    VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
+    }
+
+    VkResult
+      vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
+    }
+
+    VkResult vkCreateGraphicsPipelines( VkDevice                             device,
+                                        VkPipelineCache                      pipelineCache,
+                                        uint32_t                             createInfoCount,
+                                        const VkGraphicsPipelineCreateInfo * pCreateInfos,
+                                        const VkAllocationCallbacks *        pAllocator,
+                                        VkPipeline *                         pPipelines ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkCreateComputePipelines( VkDevice                            device,
+                                       VkPipelineCache                     pipelineCache,
+                                       uint32_t                            createInfoCount,
+                                       const VkComputePipelineCreateInfo * pCreateInfos,
+                                       const VkAllocationCallbacks *       pAllocator,
+                                       VkPipeline *                        pPipelines ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyPipeline( device, pipeline, pAllocator );
+    }
+
+    VkResult vkCreatePipelineLayout( VkDevice                           device,
+                                     const VkPipelineLayoutCreateInfo * pCreateInfo,
+                                     const VkAllocationCallbacks *      pAllocator,
+                                     VkPipelineLayout *                 pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
+    }
+
+    void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
+    }
+
+    VkResult vkCreateSampler( VkDevice                      device,
+                              const VkSamplerCreateInfo *   pCreateInfo,
+                              const VkAllocationCallbacks * pAllocator,
+                              VkSampler *                   pSampler ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
+    }
+
+    void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroySampler( device, sampler, pAllocator );
+    }
+
+    VkResult vkCreateDescriptorSetLayout( VkDevice                                device,
+                                          const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+                                          const VkAllocationCallbacks *           pAllocator,
+                                          VkDescriptorSetLayout *                 pSetLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
+    }
+
+    void vkDestroyDescriptorSetLayout( VkDevice                      device,
+                                       VkDescriptorSetLayout         descriptorSetLayout,
+                                       const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
+    }
+
+    VkResult vkCreateDescriptorPool( VkDevice                           device,
+                                     const VkDescriptorPoolCreateInfo * pCreateInfo,
+                                     const VkAllocationCallbacks *      pAllocator,
+                                     VkDescriptorPool *                 pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
+    }
+
+    void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
+    }
+
+    VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetDescriptorPool( device, descriptorPool, flags );
+    }
+
+    VkResult vkAllocateDescriptorSets( VkDevice                            device,
+                                       const VkDescriptorSetAllocateInfo * pAllocateInfo,
+                                       VkDescriptorSet *                   pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
+    }
+
+    VkResult vkFreeDescriptorSets( VkDevice                device,
+                                   VkDescriptorPool        descriptorPool,
+                                   uint32_t                descriptorSetCount,
+                                   const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
+    }
+
+    void vkUpdateDescriptorSets( VkDevice                     device,
+                                 uint32_t                     descriptorWriteCount,
+                                 const VkWriteDescriptorSet * pDescriptorWrites,
+                                 uint32_t                     descriptorCopyCount,
+                                 const VkCopyDescriptorSet *  pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
+    }
+
+    VkResult vkCreateFramebuffer( VkDevice                        device,
+                                  const VkFramebufferCreateInfo * pCreateInfo,
+                                  const VkAllocationCallbacks *   pAllocator,
+                                  VkFramebuffer *                 pFramebuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
+    }
+
+    void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
+    }
+
+    VkResult vkCreateRenderPass( VkDevice                       device,
+                                 const VkRenderPassCreateInfo * pCreateInfo,
+                                 const VkAllocationCallbacks *  pAllocator,
+                                 VkRenderPass *                 pRenderPass ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
+    }
+
+    void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyRenderPass( device, renderPass, pAllocator );
+    }
+
+    void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
+    }
+
+    VkResult vkCreateCommandPool( VkDevice                        device,
+                                  const VkCommandPoolCreateInfo * pCreateInfo,
+                                  const VkAllocationCallbacks *   pAllocator,
+                                  VkCommandPool *                 pCommandPool ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
+    }
+
+    void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyCommandPool( device, commandPool, pAllocator );
+    }
+
+    VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetCommandPool( device, commandPool, flags );
+    }
+
+    VkResult vkAllocateCommandBuffers( VkDevice                            device,
+                                       const VkCommandBufferAllocateInfo * pAllocateInfo,
+                                       VkCommandBuffer *                   pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
+    }
+
+    void vkFreeCommandBuffers( VkDevice                device,
+                               VkCommandPool           commandPool,
+                               uint32_t                commandBufferCount,
+                               const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
+    }
+
+    VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
+    }
+
+    VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEndCommandBuffer( commandBuffer );
+    }
+
+    VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetCommandBuffer( commandBuffer, flags );
+    }
+
+    void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
+    }
+
+    void
+      vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
+    }
+
+    void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
+    }
+
+    void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
+    }
+
+    void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
+                            float           depthBiasConstantFactor,
+                            float           depthBiasClamp,
+                            float           depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+    }
+
+    void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
+    }
+
+    void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
+    }
+
+    void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
+    }
+
+    void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
+    }
+
+    void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
+    }
+
+    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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindDescriptorSets(
+        commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
+    }
+
+    void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
+    }
+
+    void vkCmdBindVertexBuffers( VkCommandBuffer      commandBuffer,
+                                 uint32_t             firstBinding,
+                                 uint32_t             bindingCount,
+                                 const VkBuffer *     pBuffers,
+                                 const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
+    }
+
+    void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+    }
+
+    void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
+    }
+
+    void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
+    }
+
+    void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
+    }
+
+    void vkCmdCopyImage( VkCommandBuffer     commandBuffer,
+                         VkImage             srcImage,
+                         VkImageLayout       srcImageLayout,
+                         VkImage             dstImage,
+                         VkImageLayout       dstImageLayout,
+                         uint32_t            regionCount,
+                         const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdBlitImage( VkCommandBuffer     commandBuffer,
+                         VkImage             srcImage,
+                         VkImageLayout       srcImageLayout,
+                         VkImage             dstImage,
+                         VkImageLayout       dstImageLayout,
+                         uint32_t            regionCount,
+                         const VkImageBlit * pRegions,
+                         VkFilter            filter ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
+    }
+
+    void vkCmdCopyBufferToImage( VkCommandBuffer           commandBuffer,
+                                 VkBuffer                  srcBuffer,
+                                 VkImage                   dstImage,
+                                 VkImageLayout             dstImageLayout,
+                                 uint32_t                  regionCount,
+                                 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdCopyImageToBuffer( VkCommandBuffer           commandBuffer,
+                                 VkImage                   srcImage,
+                                 VkImageLayout             srcImageLayout,
+                                 VkBuffer                  dstBuffer,
+                                 uint32_t                  regionCount,
+                                 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
+    }
+
+    void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
+    }
+
+    void
+      vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
+    }
+
+    void vkCmdClearColorImage( VkCommandBuffer                 commandBuffer,
+                               VkImage                         image,
+                               VkImageLayout                   imageLayout,
+                               const VkClearColorValue *       pColor,
+                               uint32_t                        rangeCount,
+                               const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
+    {
+      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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
+    }
+
+    void vkCmdClearAttachments( VkCommandBuffer           commandBuffer,
+                                uint32_t                  attachmentCount,
+                                const VkClearAttachment * pAttachments,
+                                uint32_t                  rectCount,
+                                const VkClearRect *       pRects ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
+    }
+
+    void vkCmdResolveImage( VkCommandBuffer        commandBuffer,
+                            VkImage                srcImage,
+                            VkImageLayout          srcImageLayout,
+                            VkImage                dstImage,
+                            VkImageLayout          dstImageLayout,
+                            uint32_t               regionCount,
+                            const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetEvent( commandBuffer, event, stageMask );
+    }
+
+    void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdResetEvent( commandBuffer, event, stageMask );
+    }
+
+    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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWaitEvents( commandBuffer,
+                                eventCount,
+                                pEvents,
+                                srcStageMask,
+                                dstStageMask,
+                                memoryBarrierCount,
+                                pMemoryBarriers,
+                                bufferMemoryBarrierCount,
+                                pBufferMemoryBarriers,
+                                imageMemoryBarrierCount,
+                                pImageMemoryBarriers );
+    }
+
+    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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdPipelineBarrier( commandBuffer,
+                                     srcStageMask,
+                                     dstStageMask,
+                                     dependencyFlags,
+                                     memoryBarrierCount,
+                                     pMemoryBarriers,
+                                     bufferMemoryBarrierCount,
+                                     pBufferMemoryBarriers,
+                                     imageMemoryBarrierCount,
+                                     pImageMemoryBarriers );
+    }
+
+    void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
+    }
+
+    void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndQuery( commandBuffer, queryPool, query );
+    }
+
+    void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
+    }
+
+    void vkCmdWriteTimestamp( VkCommandBuffer         commandBuffer,
+                              VkPipelineStageFlagBits pipelineStage,
+                              VkQueryPool             queryPool,
+                              uint32_t                query ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
+    }
+
+    void vkCmdCopyQueryPoolResults( VkCommandBuffer    commandBuffer,
+                                    VkQueryPool        queryPool,
+                                    uint32_t           firstQuery,
+                                    uint32_t           queryCount,
+                                    VkBuffer           dstBuffer,
+                                    VkDeviceSize       dstOffset,
+                                    VkDeviceSize       stride,
+                                    VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
+    }
+
+    void vkCmdPushConstants( VkCommandBuffer    commandBuffer,
+                             VkPipelineLayout   layout,
+                             VkShaderStageFlags stageFlags,
+                             uint32_t           offset,
+                             uint32_t           size,
+                             const void *       pValues ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
+    }
+
+    void vkCmdBeginRenderPass( VkCommandBuffer               commandBuffer,
+                               const VkRenderPassBeginInfo * pRenderPassBegin,
+                               VkSubpassContents             contents ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
+    }
+
+    void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdNextSubpass( commandBuffer, contents );
+    }
+
+    void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndRenderPass( commandBuffer );
+    }
+
+    void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
+    }
+
+    //=== VK_VERSION_1_1 ===
+
+    VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateInstanceVersion( pApiVersion );
+    }
+
+    VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    void vkGetDeviceGroupPeerMemoryFeatures( VkDevice                   device,
+                                             uint32_t                   heapIndex,
+                                             uint32_t                   localDeviceIndex,
+                                             uint32_t                   remoteDeviceIndex,
+                                             VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+    }
+
+    void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
+    }
+
+    void vkCmdDispatchBase( VkCommandBuffer commandBuffer,
+                            uint32_t        baseGroupX,
+                            uint32_t        baseGroupY,
+                            uint32_t        baseGroupZ,
+                            uint32_t        groupCountX,
+                            uint32_t        groupCountY,
+                            uint32_t        groupCountZ ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceGroups( VkInstance                        instance,
+                                              uint32_t *                        pPhysicalDeviceGroupCount,
+                                              VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    void vkGetImageMemoryRequirements2( VkDevice                               device,
+                                        const VkImageMemoryRequirementsInfo2 * pInfo,
+                                        VkMemoryRequirements2 *                pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetBufferMemoryRequirements2( VkDevice                                device,
+                                         const VkBufferMemoryRequirementsInfo2 * pInfo,
+                                         VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements2( VkDevice                                     device,
+                                              const VkImageSparseMemoryRequirementsInfo2 * pInfo,
+                                              uint32_t *                                   pSparseMemoryRequirementCount,
+                                              VkSparseImageMemoryRequirements2 *           pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice      physicalDevice,
+                                               VkFormat              format,
+                                               VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice                         physicalDevice,
+                                                        const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+                                                        VkImageFormatProperties2 *               pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice           physicalDevice,
+                                                    uint32_t *                 pQueueFamilyPropertyCount,
+                                                    VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice                    physicalDevice,
+                                               VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice                               physicalDevice,
+                                                          const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+                                                          uint32_t *                                     pPropertyCount,
+                                                          VkSparseImageFormatProperties2 *               pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+    }
+
+    void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkTrimCommandPool( device, commandPool, flags );
+    }
+
+    void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
+    }
+
+    VkResult vkCreateSamplerYcbcrConversion( VkDevice                                   device,
+                                             const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
+                                             const VkAllocationCallbacks *              pAllocator,
+                                             VkSamplerYcbcrConversion *                 pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
+    }
+
+    void vkDestroySamplerYcbcrConversion( VkDevice                      device,
+                                          VkSamplerYcbcrConversion      ycbcrConversion,
+                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
+    }
+
+    VkResult vkCreateDescriptorUpdateTemplate( VkDevice                                     device,
+                                               const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
+                                               const VkAllocationCallbacks *                pAllocator,
+                                               VkDescriptorUpdateTemplate *                 pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+    }
+
+    void vkDestroyDescriptorUpdateTemplate( VkDevice                      device,
+                                            VkDescriptorUpdateTemplate    descriptorUpdateTemplate,
+                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
+    }
+
+    void vkUpdateDescriptorSetWithTemplate( VkDevice                   device,
+                                            VkDescriptorSet            descriptorSet,
+                                            VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                            const void *               pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice                           physicalDevice,
+                                                      const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+                                                      VkExternalBufferProperties *               pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice                          physicalDevice,
+                                                     const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+                                                     VkExternalFenceProperties *               pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice                              physicalDevice,
+                                                         const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+                                                         VkExternalSemaphoreProperties *               pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+    }
+
+    void vkGetDescriptorSetLayoutSupport( VkDevice                                device,
+                                          const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+                                          VkDescriptorSetLayoutSupport *          pSupport ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
+    }
+
+    //=== VK_VERSION_1_2 ===
+
+    void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer,
+                                 VkBuffer        buffer,
+                                 VkDeviceSize    offset,
+                                 VkBuffer        countBuffer,
+                                 VkDeviceSize    countBufferOffset,
+                                 uint32_t        maxDrawCount,
+                                 uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer,
+                                        VkBuffer        buffer,
+                                        VkDeviceSize    offset,
+                                        VkBuffer        countBuffer,
+                                        VkDeviceSize    countBufferOffset,
+                                        uint32_t        maxDrawCount,
+                                        uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    VkResult vkCreateRenderPass2( VkDevice                        device,
+                                  const VkRenderPassCreateInfo2 * pCreateInfo,
+                                  const VkAllocationCallbacks *   pAllocator,
+                                  VkRenderPass *                  pRenderPass ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
+    }
+
+    void vkCmdBeginRenderPass2( VkCommandBuffer               commandBuffer,
+                                const VkRenderPassBeginInfo * pRenderPassBegin,
+                                const VkSubpassBeginInfo *    pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+    }
+
+    void vkCmdNextSubpass2( VkCommandBuffer            commandBuffer,
+                            const VkSubpassBeginInfo * pSubpassBeginInfo,
+                            const VkSubpassEndInfo *   pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+    }
+
+    void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
+    }
+
+    void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
+    }
+
+    VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
+    }
+
+    VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWaitSemaphores( device, pWaitInfo, timeout );
+    }
+
+    VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSignalSemaphore( device, pSignalInfo );
+    }
+
+    VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferDeviceAddress( device, pInfo );
+    }
+
+    uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
+    }
+
+    uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
+    }
+
+    //=== VK_VERSION_1_3 ===
+
+    VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice                 physicalDevice,
+                                                uint32_t *                       pToolCount,
+                                                VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
+    }
+
+    VkResult vkCreatePrivateDataSlot( VkDevice                            device,
+                                      const VkPrivateDataSlotCreateInfo * pCreateInfo,
+                                      const VkAllocationCallbacks *       pAllocator,
+                                      VkPrivateDataSlot *                 pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
+    }
+
+    void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
+    }
+
+    VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
+    }
+
+    void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
+    }
+
+    void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
+    }
+
+    void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
+    }
+
+    void vkCmdWaitEvents2( VkCommandBuffer          commandBuffer,
+                           uint32_t                 eventCount,
+                           const VkEvent *          pEvents,
+                           const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
+    }
+
+    void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
+    }
+
+    void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
+    }
+
+    VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
+    }
+
+    void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
+    }
+
+    void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
+    }
+
+    void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
+    }
+
+    void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
+    }
+
+    void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
+    }
+
+    void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
+    }
+
+    void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
+    }
+
+    void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndRendering( commandBuffer );
+    }
+
+    void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetCullMode( commandBuffer, cullMode );
+    }
+
+    void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetFrontFace( commandBuffer, frontFace );
+    }
+
+    void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
+    }
+
+    void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
+    }
+
+    void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
+    }
+
+    void vkCmdBindVertexBuffers2( VkCommandBuffer      commandBuffer,
+                                  uint32_t             firstBinding,
+                                  uint32_t             bindingCount,
+                                  const VkBuffer *     pBuffers,
+                                  const VkDeviceSize * pOffsets,
+                                  const VkDeviceSize * pSizes,
+                                  const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
+    }
+
+    void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
+    }
+
+    void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
+    }
+
+    void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
+    }
+
+    void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
+    }
+
+    void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
+    }
+
+    void vkCmdSetStencilOp( VkCommandBuffer    commandBuffer,
+                            VkStencilFaceFlags faceMask,
+                            VkStencilOp        failOp,
+                            VkStencilOp        passOp,
+                            VkStencilOp        depthFailOp,
+                            VkCompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
+    }
+
+    void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
+    }
+
+    void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
+    }
+
+    void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
+    }
+
+    void vkGetDeviceBufferMemoryRequirements( VkDevice                                 device,
+                                              const VkDeviceBufferMemoryRequirements * pInfo,
+                                              VkMemoryRequirements2 *                  pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetDeviceImageMemoryRequirements( VkDevice                                device,
+                                             const VkDeviceImageMemoryRequirements * pInfo,
+                                             VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetDeviceImageSparseMemoryRequirements( VkDevice                                device,
+                                                   const VkDeviceImageMemoryRequirements * pInfo,
+                                                   uint32_t *                              pSparseMemoryRequirementCount,
+                                                   VkSparseImageMemoryRequirements2 *      pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    //=== VK_KHR_surface ===
+
+    void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice,
+                                                   uint32_t         queueFamilyIndex,
+                                                   VkSurfaceKHR     surface,
+                                                   VkBool32 *       pSupported ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice           physicalDevice,
+                                                        VkSurfaceKHR               surface,
+                                                        VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice     physicalDevice,
+                                                   VkSurfaceKHR         surface,
+                                                   uint32_t *           pSurfaceFormatCount,
+                                                   VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice   physicalDevice,
+                                                        VkSurfaceKHR       surface,
+                                                        uint32_t *         pPresentModeCount,
+                                                        VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
+    }
+
+    //=== VK_KHR_swapchain ===
+
+    VkResult vkCreateSwapchainKHR( VkDevice                         device,
+                                   const VkSwapchainCreateInfoKHR * pCreateInfo,
+                                   const VkAllocationCallbacks *    pAllocator,
+                                   VkSwapchainKHR *                 pSwapchain ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
+    }
+
+    void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
+    }
+
+    VkResult vkGetSwapchainImagesKHR( VkDevice       device,
+                                      VkSwapchainKHR swapchain,
+                                      uint32_t *     pSwapchainImageCount,
+                                      VkImage *      pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
+    }
+
+    VkResult vkAcquireNextImageKHR(
+      VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
+    }
+
+    VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueuePresentKHR( queue, pPresentInfo );
+    }
+
+    VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice                              device,
+                                                     VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
+    }
+
+    VkResult
+      vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
+    }
+
+    VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice,
+                                                      VkSurfaceKHR     surface,
+                                                      uint32_t *       pRectCount,
+                                                      VkRect2D *       pRects ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
+    }
+
+    VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
+    }
+
+    //=== VK_KHR_display ===
+
+    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice         physicalDevice,
+                                                      uint32_t *               pPropertyCount,
+                                                      VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice              physicalDevice,
+                                                           uint32_t *                    pPropertyCount,
+                                                           VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
+                                                    uint32_t         planeIndex,
+                                                    uint32_t *       pDisplayCount,
+                                                    VkDisplayKHR *   pDisplays ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
+    }
+
+    VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice             physicalDevice,
+                                            VkDisplayKHR                 display,
+                                            uint32_t *                   pPropertyCount,
+                                            VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult vkCreateDisplayModeKHR( VkPhysicalDevice                   physicalDevice,
+                                     VkDisplayKHR                       display,
+                                     const VkDisplayModeCreateInfoKHR * pCreateInfo,
+                                     const VkAllocationCallbacks *      pAllocator,
+                                     VkDisplayModeKHR *                 pMode ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
+    }
+
+    VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice                physicalDevice,
+                                               VkDisplayModeKHR                mode,
+                                               uint32_t                        planeIndex,
+                                               VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
+    }
+
+    VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance                            instance,
+                                             const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
+                                             const VkAllocationCallbacks *         pAllocator,
+                                             VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    //=== VK_KHR_display_swapchain ===
+
+    VkResult vkCreateSharedSwapchainsKHR( VkDevice                         device,
+                                          uint32_t                         swapchainCount,
+                                          const VkSwapchainCreateInfoKHR * pCreateInfos,
+                                          const VkAllocationCallbacks *    pAllocator,
+                                          VkSwapchainKHR *                 pSwapchains ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
+    }
+
+#  if defined( VK_USE_PLATFORM_XLIB_KHR )
+    //=== VK_KHR_xlib_surface ===
+
+    VkResult vkCreateXlibSurfaceKHR( VkInstance                         instance,
+                                     const VkXlibSurfaceCreateInfoKHR * pCreateInfo,
+                                     const VkAllocationCallbacks *      pAllocator,
+                                     VkSurfaceKHR *                     pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice,
+                                                            uint32_t         queueFamilyIndex,
+                                                            Display *        dpy,
+                                                            VisualID         visualID ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
+    }
+#  endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#  if defined( VK_USE_PLATFORM_XCB_KHR )
+    //=== VK_KHR_xcb_surface ===
+
+    VkResult vkCreateXcbSurfaceKHR( VkInstance                        instance,
+                                    const VkXcbSurfaceCreateInfoKHR * pCreateInfo,
+                                    const VkAllocationCallbacks *     pAllocator,
+                                    VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice   physicalDevice,
+                                                           uint32_t           queueFamilyIndex,
+                                                           xcb_connection_t * connection,
+                                                           xcb_visualid_t     visual_id ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
+    }
+#  endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#  if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+    //=== VK_KHR_wayland_surface ===
+
+    VkResult vkCreateWaylandSurfaceKHR( VkInstance                            instance,
+                                        const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,
+                                        const VkAllocationCallbacks *         pAllocator,
+                                        VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice    physicalDevice,
+                                                               uint32_t            queueFamilyIndex,
+                                                               struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
+    }
+#  endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
+    //=== VK_KHR_android_surface ===
+
+    VkResult vkCreateAndroidSurfaceKHR( VkInstance                            instance,
+                                        const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
+                                        const VkAllocationCallbacks *         pAllocator,
+                                        VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_win32_surface ===
+
+    VkResult vkCreateWin32SurfaceKHR( VkInstance                          instance,
+                                      const VkWin32SurfaceCreateInfoKHR * pCreateInfo,
+                                      const VkAllocationCallbacks *       pAllocator,
+                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_EXT_debug_report ===
+
+    VkResult vkCreateDebugReportCallbackEXT( VkInstance                                 instance,
+                                             const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
+                                             const VkAllocationCallbacks *              pAllocator,
+                                             VkDebugReportCallbackEXT *                 pCallback ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
+    }
+
+    void vkDestroyDebugReportCallbackEXT( VkInstance                    instance,
+                                          VkDebugReportCallbackEXT      callback,
+                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
+    }
+
+    void vkDebugReportMessageEXT( VkInstance                 instance,
+                                  VkDebugReportFlagsEXT      flags,
+                                  VkDebugReportObjectTypeEXT objectType,
+                                  uint64_t                   object,
+                                  size_t                     location,
+                                  int32_t                    messageCode,
+                                  const char *               pLayerPrefix,
+                                  const char *               pMessage ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
+    }
+
+    //=== VK_EXT_debug_marker ===
+
+    VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
+    }
+
+    VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
+    }
+
+    void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
+    }
+
+    void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDebugMarkerEndEXT( commandBuffer );
+    }
+
+    void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
+    }
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_queue ===
+
+    VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice          physicalDevice,
+                                                      const VkVideoProfileKHR * pVideoProfile,
+                                                      VkVideoCapabilitiesKHR *  pCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice                           physicalDevice,
+                                                          const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
+                                                          uint32_t *                                 pVideoFormatPropertyCount,
+                                                          VkVideoFormatPropertiesKHR *               pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
+    }
+
+    VkResult vkCreateVideoSessionKHR( VkDevice                            device,
+                                      const VkVideoSessionCreateInfoKHR * pCreateInfo,
+                                      const VkAllocationCallbacks *       pAllocator,
+                                      VkVideoSessionKHR *                 pVideoSession ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
+    }
+
+    void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
+    }
+
+    VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice                        device,
+                                                     VkVideoSessionKHR               videoSession,
+                                                     uint32_t *                      pVideoSessionMemoryRequirementsCount,
+                                                     VkVideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements );
+    }
+
+    VkResult vkBindVideoSessionMemoryKHR( VkDevice                     device,
+                                          VkVideoSessionKHR            videoSession,
+                                          uint32_t                     videoSessionBindMemoryCount,
+                                          const VkVideoBindMemoryKHR * pVideoSessionBindMemories ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindVideoSessionMemoryKHR( device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories );
+    }
+
+    VkResult vkCreateVideoSessionParametersKHR( VkDevice                                      device,
+                                                const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,
+                                                const VkAllocationCallbacks *                 pAllocator,
+                                                VkVideoSessionParametersKHR *                 pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
+    }
+
+    VkResult vkUpdateVideoSessionParametersKHR( VkDevice                                      device,
+                                                VkVideoSessionParametersKHR                   videoSessionParameters,
+                                                const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
+    }
+
+    void vkDestroyVideoSessionParametersKHR( VkDevice                      device,
+                                             VkVideoSessionParametersKHR   videoSessionParameters,
+                                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
+    }
+
+    void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
+    }
+
+    void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
+    }
+
+    void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_decode_queue ===
+
+    void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pFrameInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDecodeVideoKHR( commandBuffer, pFrameInfo );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+    //=== VK_EXT_transform_feedback ===
+
+    void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer      commandBuffer,
+                                               uint32_t             firstBinding,
+                                               uint32_t             bindingCount,
+                                               const VkBuffer *     pBuffers,
+                                               const VkDeviceSize * pOffsets,
+                                               const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
+    }
+
+    void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer      commandBuffer,
+                                         uint32_t             firstCounterBuffer,
+                                         uint32_t             counterBufferCount,
+                                         const VkBuffer *     pCounterBuffers,
+                                         const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+    }
+
+    void vkCmdEndTransformFeedbackEXT( VkCommandBuffer      commandBuffer,
+                                       uint32_t             firstCounterBuffer,
+                                       uint32_t             counterBufferCount,
+                                       const VkBuffer *     pCounterBuffers,
+                                       const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+    }
+
+    void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
+    }
+
+    void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
+    }
+
+    void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer,
+                                        uint32_t        instanceCount,
+                                        uint32_t        firstInstance,
+                                        VkBuffer        counterBuffer,
+                                        VkDeviceSize    counterBufferOffset,
+                                        uint32_t        counterOffset,
+                                        uint32_t        vertexStride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
+    }
+
+    //=== VK_NVX_binary_import ===
+
+    VkResult vkCreateCuModuleNVX( VkDevice                        device,
+                                  const VkCuModuleCreateInfoNVX * pCreateInfo,
+                                  const VkAllocationCallbacks *   pAllocator,
+                                  VkCuModuleNVX *                 pModule ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
+    }
+
+    VkResult vkCreateCuFunctionNVX( VkDevice                          device,
+                                    const VkCuFunctionCreateInfoNVX * pCreateInfo,
+                                    const VkAllocationCallbacks *     pAllocator,
+                                    VkCuFunctionNVX *                 pFunction ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
+    }
+
+    void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyCuModuleNVX( device, module, pAllocator );
+    }
+
+    void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
+    }
+
+    void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
+    }
+
+    //=== VK_NVX_image_view_handle ===
+
+    uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageViewHandleNVX( device, pInfo );
+    }
+
+    VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
+    }
+
+    //=== VK_AMD_draw_indirect_count ===
+
+    void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
+                                    VkBuffer        buffer,
+                                    VkDeviceSize    offset,
+                                    VkBuffer        countBuffer,
+                                    VkDeviceSize    countBufferOffset,
+                                    uint32_t        maxDrawCount,
+                                    uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer,
+                                           VkBuffer        buffer,
+                                           VkDeviceSize    offset,
+                                           VkBuffer        countBuffer,
+                                           VkDeviceSize    countBufferOffset,
+                                           uint32_t        maxDrawCount,
+                                           uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    //=== VK_AMD_shader_info ===
+
+    VkResult vkGetShaderInfoAMD( VkDevice              device,
+                                 VkPipeline            pipeline,
+                                 VkShaderStageFlagBits shaderStage,
+                                 VkShaderInfoTypeAMD   infoType,
+                                 size_t *              pInfoSize,
+                                 void *                pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
+    }
+
+    //=== VK_KHR_dynamic_rendering ===
+
+    void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
+    }
+
+    void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndRenderingKHR( commandBuffer );
+    }
+
+#  if defined( VK_USE_PLATFORM_GGP )
+    //=== VK_GGP_stream_descriptor_surface ===
+
+    VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance                                     instance,
+                                                 const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
+                                                 const VkAllocationCallbacks *                  pAllocator,
+                                                 VkSurfaceKHR *                                 pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_GGP*/
+
+    //=== VK_NV_external_memory_capabilities ===
+
+    VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice                    physicalDevice,
+                                                                 VkFormat                            format,
+                                                                 VkImageType                         type,
+                                                                 VkImageTiling                       tiling,
+                                                                 VkImageUsageFlags                   usage,
+                                                                 VkImageCreateFlags                  flags,
+                                                                 VkExternalMemoryHandleTypeFlagsNV   externalHandleType,
+                                                                 VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+        physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_NV_external_memory_win32 ===
+
+    VkResult vkGetMemoryWin32HandleNV( VkDevice                          device,
+                                       VkDeviceMemory                    memory,
+                                       VkExternalMemoryHandleTypeFlagsNV handleType,
+                                       HANDLE *                          pHandle ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_get_physical_device_properties2 ===
+
+    void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice      physicalDevice,
+                                                  VkFormat              format,
+                                                  VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice                         physicalDevice,
+                                                           const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+                                                           VkImageFormatProperties2 *               pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice           physicalDevice,
+                                                       uint32_t *                 pQueueFamilyPropertyCount,
+                                                       VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice                    physicalDevice,
+                                                  VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice                               physicalDevice,
+                                                             const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+                                                             uint32_t *                                     pPropertyCount,
+                                                             VkSparseImageFormatProperties2 *               pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+    }
+
+    //=== VK_KHR_device_group ===
+
+    void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice                   device,
+                                                uint32_t                   heapIndex,
+                                                uint32_t                   localDeviceIndex,
+                                                uint32_t                   remoteDeviceIndex,
+                                                VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+    }
+
+    void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
+    }
+
+    void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer,
+                               uint32_t        baseGroupX,
+                               uint32_t        baseGroupY,
+                               uint32_t        baseGroupZ,
+                               uint32_t        groupCountX,
+                               uint32_t        groupCountY,
+                               uint32_t        groupCountZ ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+    }
+
+#  if defined( VK_USE_PLATFORM_VI_NN )
+    //=== VK_NN_vi_surface ===
+
+    VkResult vkCreateViSurfaceNN( VkInstance                      instance,
+                                  const VkViSurfaceCreateInfoNN * pCreateInfo,
+                                  const VkAllocationCallbacks *   pAllocator,
+                                  VkSurfaceKHR *                  pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_VI_NN*/
+
+    //=== VK_KHR_maintenance1 ===
+
+    void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkTrimCommandPoolKHR( device, commandPool, flags );
+    }
+
+    //=== VK_KHR_device_group_creation ===
+
+    VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance                        instance,
+                                                 uint32_t *                        pPhysicalDeviceGroupCount,
+                                                 VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    //=== VK_KHR_external_memory_capabilities ===
+
+    void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice                           physicalDevice,
+                                                         const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+                                                         VkExternalBufferProperties *               pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_memory_win32 ===
+
+    VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+
+    VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice                           device,
+                                                  VkExternalMemoryHandleTypeFlagBits handleType,
+                                                  HANDLE                             handle,
+                                                  VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_memory_fd ===
+
+    VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
+    }
+
+    VkResult vkGetMemoryFdPropertiesKHR( VkDevice                           device,
+                                         VkExternalMemoryHandleTypeFlagBits handleType,
+                                         int                                fd,
+                                         VkMemoryFdPropertiesKHR *          pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
+    }
+
+    //=== VK_KHR_external_semaphore_capabilities ===
+
+    void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice                              physicalDevice,
+                                                            const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+                                                            VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_semaphore_win32 ===
+
+    VkResult vkImportSemaphoreWin32HandleKHR( VkDevice                                    device,
+                                              const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
+    }
+
+    VkResult
+      vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_semaphore_fd ===
+
+    VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
+    }
+
+    VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
+    }
+
+    //=== VK_KHR_push_descriptor ===
+
+    void vkCmdPushDescriptorSetKHR( VkCommandBuffer              commandBuffer,
+                                    VkPipelineBindPoint          pipelineBindPoint,
+                                    VkPipelineLayout             layout,
+                                    uint32_t                     set,
+                                    uint32_t                     descriptorWriteCount,
+                                    const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
+    }
+
+    void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer            commandBuffer,
+                                                VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                VkPipelineLayout           layout,
+                                                uint32_t                   set,
+                                                const void *               pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
+    }
+
+    //=== VK_EXT_conditional_rendering ===
+
+    void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer                            commandBuffer,
+                                            const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
+    }
+
+    void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
+    }
+
+    //=== VK_KHR_descriptor_update_template ===
+
+    VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice                                     device,
+                                                  const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
+                                                  const VkAllocationCallbacks *                pAllocator,
+                                                  VkDescriptorUpdateTemplate *                 pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+    }
+
+    void vkDestroyDescriptorUpdateTemplateKHR( VkDevice                      device,
+                                               VkDescriptorUpdateTemplate    descriptorUpdateTemplate,
+                                               const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
+    }
+
+    void vkUpdateDescriptorSetWithTemplateKHR( VkDevice                   device,
+                                               VkDescriptorSet            descriptorSet,
+                                               VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                               const void *               pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    //=== VK_NV_clip_space_w_scaling ===
+
+    void vkCmdSetViewportWScalingNV( VkCommandBuffer              commandBuffer,
+                                     uint32_t                     firstViewport,
+                                     uint32_t                     viewportCount,
+                                     const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
+    }
+
+    //=== VK_EXT_direct_mode_display ===
+
+    VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleaseDisplayEXT( physicalDevice, display );
+    }
+
+#  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+    //=== VK_EXT_acquire_xlib_display ===
+
+    VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
+    }
+
+    VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
+    }
+#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    //=== VK_EXT_display_surface_counter ===
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice            physicalDevice,
+                                                         VkSurfaceKHR                surface,
+                                                         VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
+    }
+
+    //=== VK_EXT_display_control ===
+
+    VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
+    }
+
+    VkResult vkRegisterDeviceEventEXT( VkDevice                      device,
+                                       const VkDeviceEventInfoEXT *  pDeviceEventInfo,
+                                       const VkAllocationCallbacks * pAllocator,
+                                       VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkRegisterDisplayEventEXT( VkDevice                      device,
+                                        VkDisplayKHR                  display,
+                                        const VkDisplayEventInfoEXT * pDisplayEventInfo,
+                                        const VkAllocationCallbacks * pAllocator,
+                                        VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkGetSwapchainCounterEXT( VkDevice                    device,
+                                       VkSwapchainKHR              swapchain,
+                                       VkSurfaceCounterFlagBitsEXT counter,
+                                       uint64_t *                  pCounterValue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
+    }
+
+    //=== VK_GOOGLE_display_timing ===
+
+    VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice                       device,
+                                              VkSwapchainKHR                 swapchain,
+                                              VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
+    }
+
+    VkResult vkGetPastPresentationTimingGOOGLE( VkDevice                         device,
+                                                VkSwapchainKHR                   swapchain,
+                                                uint32_t *                       pPresentationTimingCount,
+                                                VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
+    }
+
+    //=== VK_EXT_discard_rectangles ===
+
+    void vkCmdSetDiscardRectangleEXT( VkCommandBuffer  commandBuffer,
+                                      uint32_t         firstDiscardRectangle,
+                                      uint32_t         discardRectangleCount,
+                                      const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
+    }
+
+    //=== VK_EXT_hdr_metadata ===
+
+    void vkSetHdrMetadataEXT( VkDevice                 device,
+                              uint32_t                 swapchainCount,
+                              const VkSwapchainKHR *   pSwapchains,
+                              const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
+    }
+
+    //=== VK_KHR_create_renderpass2 ===
+
+    VkResult vkCreateRenderPass2KHR( VkDevice                        device,
+                                     const VkRenderPassCreateInfo2 * pCreateInfo,
+                                     const VkAllocationCallbacks *   pAllocator,
+                                     VkRenderPass *                  pRenderPass ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
+    }
+
+    void vkCmdBeginRenderPass2KHR( VkCommandBuffer               commandBuffer,
+                                   const VkRenderPassBeginInfo * pRenderPassBegin,
+                                   const VkSubpassBeginInfo *    pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+    }
+
+    void vkCmdNextSubpass2KHR( VkCommandBuffer            commandBuffer,
+                               const VkSubpassBeginInfo * pSubpassBeginInfo,
+                               const VkSubpassEndInfo *   pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+    }
+
+    void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
+    }
+
+    //=== VK_KHR_shared_presentable_image ===
+
+    VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSwapchainStatusKHR( device, swapchain );
+    }
+
+    //=== VK_KHR_external_fence_capabilities ===
+
+    void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice                          physicalDevice,
+                                                        const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+                                                        VkExternalFenceProperties *               pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_fence_win32 ===
+
+    VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
+    }
+
+    VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_fence_fd ===
+
+    VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
+    }
+
+    VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
+    }
+
+    //=== VK_KHR_performance_query ===
+
+    VkResult
+      vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice                     physicalDevice,
+                                                                       uint32_t                             queueFamilyIndex,
+                                                                       uint32_t *                           pCounterCount,
+                                                                       VkPerformanceCounterKHR *            pCounters,
+                                                                       VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+        physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice                            physicalDevice,
+                                                                  const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
+                                                                  uint32_t *                                  pNumPasses ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
+    }
+
+    VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireProfilingLockKHR( device, pInfo );
+    }
+
+    void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleaseProfilingLockKHR( device );
+    }
+
+    //=== VK_KHR_get_surface_capabilities2 ===
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice                        physicalDevice,
+                                                         const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                         VkSurfaceCapabilities2KHR *             pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice                        physicalDevice,
+                                                    const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                    uint32_t *                              pSurfaceFormatCount,
+                                                    VkSurfaceFormat2KHR *                   pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
+    }
+
+    //=== VK_KHR_get_display_properties2 ===
+
+    VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice          physicalDevice,
+                                                       uint32_t *                pPropertyCount,
+                                                       VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice               physicalDevice,
+                                                            uint32_t *                     pPropertyCount,
+                                                            VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice              physicalDevice,
+                                             VkDisplayKHR                  display,
+                                             uint32_t *                    pPropertyCount,
+                                             VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice                 physicalDevice,
+                                                const VkDisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
+                                                VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
+    }
+
+#  if defined( VK_USE_PLATFORM_IOS_MVK )
+    //=== VK_MVK_ios_surface ===
+
+    VkResult vkCreateIOSSurfaceMVK( VkInstance                        instance,
+                                    const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
+                                    const VkAllocationCallbacks *     pAllocator,
+                                    VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#  if defined( VK_USE_PLATFORM_MACOS_MVK )
+    //=== VK_MVK_macos_surface ===
+
+    VkResult vkCreateMacOSSurfaceMVK( VkInstance                          instance,
+                                      const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
+                                      const VkAllocationCallbacks *       pAllocator,
+                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+    //=== VK_EXT_debug_utils ===
+
+    VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
+    }
+
+    VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
+    }
+
+    void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
+    }
+
+    void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueEndDebugUtilsLabelEXT( queue );
+    }
+
+    void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
+    }
+
+    void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+    }
+
+    void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
+    }
+
+    void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+    }
+
+    VkResult vkCreateDebugUtilsMessengerEXT( VkInstance                                 instance,
+                                             const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
+                                             const VkAllocationCallbacks *              pAllocator,
+                                             VkDebugUtilsMessengerEXT *                 pMessenger ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
+    }
+
+    void vkDestroyDebugUtilsMessengerEXT( VkInstance                    instance,
+                                          VkDebugUtilsMessengerEXT      messenger,
+                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
+    }
+
+    void vkSubmitDebugUtilsMessageEXT( VkInstance                                   instance,
+                                       VkDebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
+                                       VkDebugUtilsMessageTypeFlagsEXT              messageTypes,
+                                       const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
+    }
+
+#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
+    //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+
+    VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice                                   device,
+                                                          const struct AHardwareBuffer *             buffer,
+                                                          VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
+    }
+
+    VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice                                            device,
+                                                      const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
+                                                      struct AHardwareBuffer **                           pBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
+    }
+#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    //=== VK_EXT_sample_locations ===
+
+    void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
+    }
+
+    void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice             physicalDevice,
+                                                      VkSampleCountFlagBits        samples,
+                                                      VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
+    }
+
+    //=== VK_KHR_get_memory_requirements2 ===
+
+    void vkGetImageMemoryRequirements2KHR( VkDevice                               device,
+                                           const VkImageMemoryRequirementsInfo2 * pInfo,
+                                           VkMemoryRequirements2 *                pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetBufferMemoryRequirements2KHR( VkDevice                                device,
+                                            const VkBufferMemoryRequirementsInfo2 * pInfo,
+                                            VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements2KHR( VkDevice                                     device,
+                                                 const VkImageSparseMemoryRequirementsInfo2 * pInfo,
+                                                 uint32_t *                                   pSparseMemoryRequirementCount,
+                                                 VkSparseImageMemoryRequirements2 *           pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    //=== VK_KHR_acceleration_structure ===
+
+    VkResult vkCreateAccelerationStructureKHR( VkDevice                                     device,
+                                               const VkAccelerationStructureCreateInfoKHR * pCreateInfo,
+                                               const VkAllocationCallbacks *                pAllocator,
+                                               VkAccelerationStructureKHR *                 pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
+    }
+
+    void vkDestroyAccelerationStructureKHR( VkDevice                      device,
+                                            VkAccelerationStructureKHR    accelerationStructure,
+                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
+    }
+
+    void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer                                          commandBuffer,
+                                              uint32_t                                                 infoCount,
+                                              const VkAccelerationStructureBuildGeometryInfoKHR *      pInfos,
+                                              const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
+    }
+
+    void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer                                     commandBuffer,
+                                                      uint32_t                                            infoCount,
+                                                      const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
+                                                      const VkDeviceAddress *                             pIndirectDeviceAddresses,
+                                                      const uint32_t *                                    pIndirectStrides,
+                                                      const uint32_t * const *                            ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBuildAccelerationStructuresIndirectKHR(
+        commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
+    }
+
+    VkResult vkBuildAccelerationStructuresKHR( VkDevice                                                 device,
+                                               VkDeferredOperationKHR                                   deferredOperation,
+                                               uint32_t                                                 infoCount,
+                                               const VkAccelerationStructureBuildGeometryInfoKHR *      pInfos,
+                                               const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
+    }
+
+    VkResult vkCopyAccelerationStructureKHR( VkDevice                                   device,
+                                             VkDeferredOperationKHR                     deferredOperation,
+                                             const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
+    }
+
+    VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice                                           device,
+                                                     VkDeferredOperationKHR                             deferredOperation,
+                                                     const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
+    }
+
+    VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice                                           device,
+                                                     VkDeferredOperationKHR                             deferredOperation,
+                                                     const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
+    }
+
+    VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice                           device,
+                                                         uint32_t                           accelerationStructureCount,
+                                                         const VkAccelerationStructureKHR * pAccelerationStructures,
+                                                         VkQueryType                        queryType,
+                                                         size_t                             dataSize,
+                                                         void *                             pData,
+                                                         size_t                             stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
+    }
+
+    void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
+    }
+
+    void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer                                    commandBuffer,
+                                                    const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo );
+    }
+
+    void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer                                    commandBuffer,
+                                                    const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo );
+    }
+
+    VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice                                            device,
+                                                                const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo );
+    }
+
+    void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer                    commandBuffer,
+                                                        uint32_t                           accelerationStructureCount,
+                                                        const VkAccelerationStructureKHR * pAccelerationStructures,
+                                                        VkQueryType                        queryType,
+                                                        VkQueryPool                        queryPool,
+                                                        uint32_t                           firstQuery ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
+        commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+    }
+
+    void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice                                      device,
+                                                           const VkAccelerationStructureVersionInfoKHR * pVersionInfo,
+                                                           VkAccelerationStructureCompatibilityKHR *     pCompatibility ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
+    }
+
+    void vkGetAccelerationStructureBuildSizesKHR( VkDevice                                            device,
+                                                  VkAccelerationStructureBuildTypeKHR                 buildType,
+                                                  const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
+                                                  const uint32_t *                                    pMaxPrimitiveCounts,
+                                                  VkAccelerationStructureBuildSizesInfoKHR *          pSizeInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
+    }
+
+    //=== VK_KHR_sampler_ycbcr_conversion ===
+
+    VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice                                   device,
+                                                const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
+                                                const VkAllocationCallbacks *              pAllocator,
+                                                VkSamplerYcbcrConversion *                 pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
+    }
+
+    void vkDestroySamplerYcbcrConversionKHR( VkDevice                      device,
+                                             VkSamplerYcbcrConversion      ycbcrConversion,
+                                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
+    }
+
+    //=== VK_KHR_bind_memory2 ===
+
+    VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+    //=== VK_EXT_image_drm_format_modifier ===
+
+    VkResult
+      vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
+    }
+
+    //=== VK_EXT_validation_cache ===
+
+    VkResult vkCreateValidationCacheEXT( VkDevice                               device,
+                                         const VkValidationCacheCreateInfoEXT * pCreateInfo,
+                                         const VkAllocationCallbacks *          pAllocator,
+                                         VkValidationCacheEXT *                 pValidationCache ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
+    }
+
+    void
+      vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
+    }
+
+    VkResult vkMergeValidationCachesEXT( VkDevice                     device,
+                                         VkValidationCacheEXT         dstCache,
+                                         uint32_t                     srcCacheCount,
+                                         const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
+    }
+
+    VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
+    }
+
+    //=== VK_NV_shading_rate_image ===
+
+    void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
+    }
+
+    void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer                commandBuffer,
+                                               uint32_t                       firstViewport,
+                                               uint32_t                       viewportCount,
+                                               const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
+    }
+
+    void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer                     commandBuffer,
+                                      VkCoarseSampleOrderTypeNV           sampleOrderType,
+                                      uint32_t                            customSampleOrderCount,
+                                      const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
+    }
+
+    //=== VK_NV_ray_tracing ===
+
+    VkResult vkCreateAccelerationStructureNV( VkDevice                                    device,
+                                              const VkAccelerationStructureCreateInfoNV * pCreateInfo,
+                                              const VkAllocationCallbacks *               pAllocator,
+                                              VkAccelerationStructureNV *                 pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
+    }
+
+    void vkDestroyAccelerationStructureNV( VkDevice                      device,
+                                           VkAccelerationStructureNV     accelerationStructure,
+                                           const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
+    }
+
+    void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice                                                device,
+                                                         const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,
+                                                         VkMemoryRequirements2KHR *                              pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
+    }
+
+    VkResult vkBindAccelerationStructureMemoryNV( VkDevice                                        device,
+                                                  uint32_t                                        bindInfoCount,
+                                                  const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
+    }
+
+    void vkCmdBuildAccelerationStructureNV( VkCommandBuffer                       commandBuffer,
+                                            const VkAccelerationStructureInfoNV * pInfo,
+                                            VkBuffer                              instanceData,
+                                            VkDeviceSize                          instanceOffset,
+                                            VkBool32                              update,
+                                            VkAccelerationStructureNV             dst,
+                                            VkAccelerationStructureNV             src,
+                                            VkBuffer                              scratch,
+                                            VkDeviceSize                          scratchOffset ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
+    }
+
+    void vkCmdCopyAccelerationStructureNV( VkCommandBuffer                    commandBuffer,
+                                           VkAccelerationStructureNV          dst,
+                                           VkAccelerationStructureNV          src,
+                                           VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
+    }
+
+    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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdTraceRaysNV( commandBuffer,
+                                 raygenShaderBindingTableBuffer,
+                                 raygenShaderBindingOffset,
+                                 missShaderBindingTableBuffer,
+                                 missShaderBindingOffset,
+                                 missShaderBindingStride,
+                                 hitShaderBindingTableBuffer,
+                                 hitShaderBindingOffset,
+                                 hitShaderBindingStride,
+                                 callableShaderBindingTableBuffer,
+                                 callableShaderBindingOffset,
+                                 callableShaderBindingStride,
+                                 width,
+                                 height,
+                                 depth );
+    }
+
+    VkResult vkCreateRayTracingPipelinesNV( VkDevice                                 device,
+                                            VkPipelineCache                          pipelineCache,
+                                            uint32_t                                 createInfoCount,
+                                            const VkRayTracingPipelineCreateInfoNV * pCreateInfos,
+                                            const VkAllocationCallbacks *            pAllocator,
+                                            VkPipeline *                             pPipelines ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkGetRayTracingShaderGroupHandlesNV(
+      VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
+    }
+
+    VkResult vkGetAccelerationStructureHandleNV( VkDevice                  device,
+                                                 VkAccelerationStructureNV accelerationStructure,
+                                                 size_t                    dataSize,
+                                                 void *                    pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
+    }
+
+    void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer                   commandBuffer,
+                                                       uint32_t                          accelerationStructureCount,
+                                                       const VkAccelerationStructureNV * pAccelerationStructures,
+                                                       VkQueryType                       queryType,
+                                                       VkQueryPool                       queryPool,
+                                                       uint32_t                          firstQuery ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWriteAccelerationStructuresPropertiesNV(
+        commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+    }
+
+    VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCompileDeferredNV( device, pipeline, shader );
+    }
+
+    //=== VK_KHR_maintenance3 ===
+
+    void vkGetDescriptorSetLayoutSupportKHR( VkDevice                                device,
+                                             const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+                                             VkDescriptorSetLayoutSupport *          pSupport ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
+    }
+
+    //=== VK_KHR_draw_indirect_count ===
+
+    void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer,
+                                    VkBuffer        buffer,
+                                    VkDeviceSize    offset,
+                                    VkBuffer        countBuffer,
+                                    VkDeviceSize    countBufferOffset,
+                                    uint32_t        maxDrawCount,
+                                    uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndirectCountKHR( 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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    //=== VK_EXT_external_memory_host ===
+
+    VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice                           device,
+                                                  VkExternalMemoryHandleTypeFlagBits handleType,
+                                                  const void *                       pHostPointer,
+                                                  VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
+    }
+
+    //=== VK_AMD_buffer_marker ===
+
+    void vkCmdWriteBufferMarkerAMD( VkCommandBuffer         commandBuffer,
+                                    VkPipelineStageFlagBits pipelineStage,
+                                    VkBuffer                dstBuffer,
+                                    VkDeviceSize            dstOffset,
+                                    uint32_t                marker ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
+    }
+
+    //=== VK_EXT_calibrated_timestamps ===
+
+    VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice  physicalDevice,
+                                                             uint32_t *        pTimeDomainCount,
+                                                             VkTimeDomainEXT * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
+    }
+
+    VkResult vkGetCalibratedTimestampsEXT( VkDevice                             device,
+                                           uint32_t                             timestampCount,
+                                           const VkCalibratedTimestampInfoEXT * pTimestampInfos,
+                                           uint64_t *                           pTimestamps,
+                                           uint64_t *                           pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
+    }
+
+    //=== VK_NV_mesh_shader ===
+
+    void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
+    }
+
+    void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer,
+                                            VkBuffer        buffer,
+                                            VkDeviceSize    offset,
+                                            VkBuffer        countBuffer,
+                                            VkDeviceSize    countBufferOffset,
+                                            uint32_t        maxDrawCount,
+                                            uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    //=== VK_NV_scissor_exclusive ===
+
+    void vkCmdSetExclusiveScissorNV( VkCommandBuffer  commandBuffer,
+                                     uint32_t         firstExclusiveScissor,
+                                     uint32_t         exclusiveScissorCount,
+                                     const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
+    }
+
+    //=== VK_NV_device_diagnostic_checkpoints ===
+
+    void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
+    }
+
+    void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
+    }
+
+    //=== VK_KHR_timeline_semaphore ===
+
+    VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
+    }
+
+    VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
+    }
+
+    VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSignalSemaphoreKHR( device, pSignalInfo );
+    }
+
+    //=== VK_INTEL_performance_query ===
+
+    VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
+    }
+
+    void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUninitializePerformanceApiINTEL( device );
+    }
+
+    VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
+    }
+
+    VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer                            commandBuffer,
+                                                   const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
+    }
+
+    VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
+    }
+
+    VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice                                           device,
+                                                     const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
+                                                     VkPerformanceConfigurationINTEL *                  pConfiguration ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
+    }
+
+    VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
+    }
+
+    VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration );
+    }
+
+    VkResult
+      vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
+    }
+
+    //=== VK_AMD_display_native_hdr ===
+
+    void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
+    }
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_imagepipe_surface ===
+
+    VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance                                  instance,
+                                              const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
+                                              const VkAllocationCallbacks *               pAllocator,
+                                              VkSurfaceKHR *                              pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#  if defined( VK_USE_PLATFORM_METAL_EXT )
+    //=== VK_EXT_metal_surface ===
+
+    VkResult vkCreateMetalSurfaceEXT( VkInstance                          instance,
+                                      const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
+                                      const VkAllocationCallbacks *       pAllocator,
+                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+    //=== VK_KHR_fragment_shading_rate ===
+
+    VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice                         physicalDevice,
+                                                         uint32_t *                               pFragmentShadingRateCount,
+                                                         VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
+    }
+
+    void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer                          commandBuffer,
+                                         const VkExtent2D *                       pFragmentSize,
+                                         const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
+    }
+
+    //=== VK_EXT_buffer_device_address ===
+
+    VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferDeviceAddressEXT( device, pInfo );
+    }
+
+    //=== VK_EXT_tooling_info ===
+
+    VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice                 physicalDevice,
+                                                   uint32_t *                       pToolCount,
+                                                   VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
+    }
+
+    //=== VK_KHR_present_wait ===
+
+    VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
+    }
+
+    //=== VK_NV_cooperative_matrix ===
+
+    VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice                  physicalDevice,
+                                                               uint32_t *                        pPropertyCount,
+                                                               VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    //=== VK_NV_coverage_reduction_mode ===
+
+    VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+      VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations );
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_EXT_full_screen_exclusive ===
+
+    VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice                        physicalDevice,
+                                                         const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                         uint32_t *                              pPresentModeCount,
+                                                         VkPresentModeKHR *                      pPresentModes ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
+    }
+
+    VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
+    }
+
+    VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
+    }
+
+    VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice                                device,
+                                                      const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                      VkDeviceGroupPresentModeFlagsKHR *      pModes ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_EXT_headless_surface ===
+
+    VkResult vkCreateHeadlessSurfaceEXT( VkInstance                             instance,
+                                         const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
+                                         const VkAllocationCallbacks *          pAllocator,
+                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    //=== VK_KHR_buffer_device_address ===
+
+    VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferDeviceAddressKHR( device, pInfo );
+    }
+
+    uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo );
+    }
+
+    uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo );
+    }
+
+    //=== VK_EXT_line_rasterization ===
+
+    void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
+    }
+
+    //=== VK_EXT_host_query_reset ===
+
+    void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
+    }
+
+    //=== VK_EXT_extended_dynamic_state ===
+
+    void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
+    }
+
+    void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
+    }
+
+    void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
+    }
+
+    void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
+    }
+
+    void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
+    }
+
+    void vkCmdBindVertexBuffers2EXT( VkCommandBuffer      commandBuffer,
+                                     uint32_t             firstBinding,
+                                     uint32_t             bindingCount,
+                                     const VkBuffer *     pBuffers,
+                                     const VkDeviceSize * pOffsets,
+                                     const VkDeviceSize * pSizes,
+                                     const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
+    }
+
+    void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
+    }
+
+    void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
+    }
+
+    void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
+    }
+
+    void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
+    }
+
+    void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
+    }
+
+    void vkCmdSetStencilOpEXT( VkCommandBuffer    commandBuffer,
+                               VkStencilFaceFlags faceMask,
+                               VkStencilOp        failOp,
+                               VkStencilOp        passOp,
+                               VkStencilOp        depthFailOp,
+                               VkCompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
+    }
+
+    //=== VK_KHR_deferred_host_operations ===
+
+    VkResult vkCreateDeferredOperationKHR( VkDevice                      device,
+                                           const VkAllocationCallbacks * pAllocator,
+                                           VkDeferredOperationKHR *      pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
+    }
+
+    void vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
+    }
+
+    uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation );
+    }
+
+    VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeferredOperationResultKHR( device, operation );
+    }
+
+    VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDeferredOperationJoinKHR( device, operation );
+    }
+
+    //=== VK_KHR_pipeline_executable_properties ===
+
+    VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice                            device,
+                                                   const VkPipelineInfoKHR *           pPipelineInfo,
+                                                   uint32_t *                          pExecutableCount,
+                                                   VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
+    }
+
+    VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice                            device,
+                                                   const VkPipelineExecutableInfoKHR * pExecutableInfo,
+                                                   uint32_t *                          pStatisticCount,
+                                                   VkPipelineExecutableStatisticKHR *  pStatistics ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
+    }
+
+    VkResult
+      vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice                                        device,
+                                                         const VkPipelineExecutableInfoKHR *             pExecutableInfo,
+                                                         uint32_t *                                      pInternalRepresentationCount,
+                                                         VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
+    }
+
+    //=== VK_NV_device_generated_commands ===
+
+    void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice                                            device,
+                                                     const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,
+                                                     VkMemoryRequirements2 *                             pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
+    }
+
+    void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer                   commandBuffer,
+                                          VkBool32                          isPreprocessed,
+                                          const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
+    }
+
+    void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer     commandBuffer,
+                                         VkPipelineBindPoint pipelineBindPoint,
+                                         VkPipeline          pipeline,
+                                         uint32_t            groupIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
+    }
+
+    VkResult vkCreateIndirectCommandsLayoutNV( VkDevice                                     device,
+                                               const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,
+                                               const VkAllocationCallbacks *                pAllocator,
+                                               VkIndirectCommandsLayoutNV *                 pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
+    }
+
+    void vkDestroyIndirectCommandsLayoutNV( VkDevice                      device,
+                                            VkIndirectCommandsLayoutNV    indirectCommandsLayout,
+                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
+    }
+
+    //=== VK_EXT_acquire_drm_display ===
+
+    VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
+    }
+
+    VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
+    }
+
+    //=== VK_EXT_private_data ===
+
+    VkResult vkCreatePrivateDataSlotEXT( VkDevice                            device,
+                                         const VkPrivateDataSlotCreateInfo * pCreateInfo,
+                                         const VkAllocationCallbacks *       pAllocator,
+                                         VkPrivateDataSlot *                 pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
+    }
+
+    void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
+    }
+
+    VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
+    }
+
+    void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
+    }
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_encode_queue ===
+
+    void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#  if defined( VK_USE_PLATFORM_METAL_EXT )
+    //=== VK_EXT_metal_objects ===
+
+    void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
+    }
+#  endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+    //=== VK_KHR_synchronization2 ===
+
+    void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
+    }
+
+    void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
+    }
+
+    void vkCmdWaitEvents2KHR( VkCommandBuffer          commandBuffer,
+                              uint32_t                 eventCount,
+                              const VkEvent *          pEvents,
+                              const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
+    }
+
+    void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
+    }
+
+    void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
+    }
+
+    VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
+    }
+
+    void vkCmdWriteBufferMarker2AMD(
+      VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
+    }
+
+    void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
+    }
+
+    //=== VK_NV_fragment_shading_rate_enums ===
+
+    void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer                          commandBuffer,
+                                            VkFragmentShadingRateNV                  shadingRate,
+                                            const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
+    }
+
+    //=== VK_KHR_copy_commands2 ===
+
+    void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
+    }
+
+    void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
+    }
+
+    void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
+    }
+
+    void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
+    }
+
+    void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
+    }
+
+    void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
+    }
+
+    //=== VK_EXT_image_compression_control ===
+
+    void vkGetImageSubresourceLayout2EXT( VkDevice                       device,
+                                          VkImage                        image,
+                                          const VkImageSubresource2EXT * pSubresource,
+                                          VkSubresourceLayout2EXT *      pLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_NV_acquire_winrt_display ===
+
+    VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
+    }
+
+    VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#  if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+    //=== VK_EXT_directfb_surface ===
+
+    VkResult vkCreateDirectFBSurfaceEXT( VkInstance                             instance,
+                                         const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                         const VkAllocationCallbacks *          pAllocator,
+                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    VkBool32
+      vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
+    }
+#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+    //=== VK_KHR_ray_tracing_pipeline ===
+
+    void vkCmdTraceRaysKHR( VkCommandBuffer                         commandBuffer,
+                            const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+                            const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+                            const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+                            const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+                            uint32_t                                width,
+                            uint32_t                                height,
+                            uint32_t                                depth ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdTraceRaysKHR(
+        commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
+    }
+
+    VkResult vkCreateRayTracingPipelinesKHR( VkDevice                                  device,
+                                             VkDeferredOperationKHR                    deferredOperation,
+                                             VkPipelineCache                           pipelineCache,
+                                             uint32_t                                  createInfoCount,
+                                             const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
+                                             const VkAllocationCallbacks *             pAllocator,
+                                             VkPipeline *                              pPipelines ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkGetRayTracingShaderGroupHandlesKHR(
+      VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
+    }
+
+    VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+      VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
+    }
+
+    void vkCmdTraceRaysIndirectKHR( VkCommandBuffer                         commandBuffer,
+                                    const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+                                    const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+                                    const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+                                    const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+                                    VkDeviceAddress                         indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdTraceRaysIndirectKHR(
+        commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
+    }
+
+    VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice               device,
+                                                         VkPipeline             pipeline,
+                                                         uint32_t               group,
+                                                         VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
+    }
+
+    void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
+    }
+
+    //=== VK_EXT_vertex_input_dynamic_state ===
+
+    void vkCmdSetVertexInputEXT( VkCommandBuffer                               commandBuffer,
+                                 uint32_t                                      vertexBindingDescriptionCount,
+                                 const VkVertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
+                                 uint32_t                                      vertexAttributeDescriptionCount,
+                                 const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetVertexInputEXT(
+        commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
+    }
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_external_memory ===
+
+    VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice                                   device,
+                                             const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+                                             zx_handle_t *                              pZirconHandle ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
+    }
+
+    VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice                                device,
+                                                       VkExternalMemoryHandleTypeFlagBits      handleType,
+                                                       zx_handle_t                             zirconHandle,
+                                                       VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
+    }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_external_semaphore ===
+
+    VkResult vkImportSemaphoreZirconHandleFUCHSIA( VkDevice                                         device,
+                                                   const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
+    }
+
+    VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice                                      device,
+                                                const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+                                                zx_handle_t *                                 pZirconHandle ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
+    }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_buffer_collection ===
+
+    VkResult vkCreateBufferCollectionFUCHSIA( VkDevice                                    device,
+                                              const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
+                                              const VkAllocationCallbacks *               pAllocator,
+                                              VkBufferCollectionFUCHSIA *                 pCollection ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
+    }
+
+    VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice                              device,
+                                                           VkBufferCollectionFUCHSIA             collection,
+                                                           const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
+    }
+
+    VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice                               device,
+                                                            VkBufferCollectionFUCHSIA              collection,
+                                                            const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
+    }
+
+    void vkDestroyBufferCollectionFUCHSIA( VkDevice                      device,
+                                           VkBufferCollectionFUCHSIA     collection,
+                                           const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
+    }
+
+    VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice                              device,
+                                                     VkBufferCollectionFUCHSIA             collection,
+                                                     VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
+    }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+    //=== VK_HUAWEI_subpass_shading ===
+
+    VkResult
+      vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
+    }
+
+    void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
+    }
+
+    //=== VK_HUAWEI_invocation_mask ===
+
+    void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
+    }
+
+    //=== VK_NV_external_memory_rdma ===
+
+    VkResult vkGetMemoryRemoteAddressNV( VkDevice                               device,
+                                         const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
+                                         VkRemoteAddressNV *                    pAddress ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
+    }
+
+    //=== VK_EXT_pipeline_properties ===
+
+    VkResult
+      vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT * pPipelineInfo, VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
+    }
+
+    //=== VK_EXT_extended_dynamic_state2 ===
+
+    void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
+    }
+
+    void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
+    }
+
+    void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
+    }
+
+    void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
+    }
+
+    void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
+    }
+
+#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
+    //=== VK_QNX_screen_surface ===
+
+    VkResult vkCreateScreenSurfaceQNX( VkInstance                           instance,
+                                       const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
+                                       const VkAllocationCallbacks *        pAllocator,
+                                       VkSurfaceKHR *                       pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+    VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice        physicalDevice,
+                                                              uint32_t                queueFamilyIndex,
+                                                              struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
+    }
+#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+    //=== VK_EXT_color_write_enable ===
+
+    void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
+    }
+
+    //=== VK_KHR_ray_tracing_maintenance1 ===
+
+    void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
+    }
+
+    //=== VK_EXT_multi_draw ===
+
+    void vkCmdDrawMultiEXT( VkCommandBuffer            commandBuffer,
+                            uint32_t                   drawCount,
+                            const VkMultiDrawInfoEXT * pVertexInfo,
+                            uint32_t                   instanceCount,
+                            uint32_t                   firstInstance,
+                            uint32_t                   stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
+    }
+
+    void vkCmdDrawMultiIndexedEXT( VkCommandBuffer                   commandBuffer,
+                                   uint32_t                          drawCount,
+                                   const VkMultiDrawIndexedInfoEXT * pIndexInfo,
+                                   uint32_t                          instanceCount,
+                                   uint32_t                          firstInstance,
+                                   uint32_t                          stride,
+                                   const int32_t *                   pVertexOffset ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
+    }
+
+    //=== VK_EXT_pageable_device_local_memory ===
+
+    void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
+    }
+
+    //=== VK_KHR_maintenance4 ===
+
+    void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice                                 device,
+                                                 const VkDeviceBufferMemoryRequirements * pInfo,
+                                                 VkMemoryRequirements2 *                  pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetDeviceImageMemoryRequirementsKHR( VkDevice                                device,
+                                                const VkDeviceImageMemoryRequirements * pInfo,
+                                                VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice                                device,
+                                                      const VkDeviceImageMemoryRequirements * pInfo,
+                                                      uint32_t *                              pSparseMemoryRequirementCount,
+                                                      VkSparseImageMemoryRequirements2 *      pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    //=== VK_VALVE_descriptor_set_host_mapping ===
+
+    void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice                                     device,
+                                                       const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
+                                                       VkDescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
+    }
+
+    void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
+    }
+
+    //=== VK_EXT_shader_module_identifier ===
+
+    void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
+    }
+
+    void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice                         device,
+                                                   const VkShaderModuleCreateInfo * pCreateInfo,
+                                                   VkShaderModuleIdentifierEXT *    pIdentifier ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
+    }
+
+    //=== VK_QCOM_tile_properties ===
+
+    VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice               device,
+                                                 VkFramebuffer          framebuffer,
+                                                 uint32_t *             pPropertiesCount,
+                                                 VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
+    }
+
+    VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice                device,
+                                                      const VkRenderingInfo * pRenderingInfo,
+                                                      VkTilePropertiesQCOM *  pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
+    }
+  };
 #endif
 
-class DispatchLoaderBase
-{
-public:
-	DispatchLoaderBase() = default;
-	DispatchLoaderBase(std::nullptr_t)
-#if !defined(NDEBUG)
-	    : m_valid(false)
-#endif
-	{
-	}
-
-#if !defined(NDEBUG)
-	size_t getVkHeaderVersion() const
-	{
-		VULKAN_HPP_ASSERT(m_valid);
-		return vkHeaderVersion;
-	}
-
-private:
-	size_t vkHeaderVersion = VK_HEADER_VERSION;
-	bool m_valid = true;
-#endif
-};
-
-#if !defined(VK_NO_PROTOTYPES)
-class DispatchLoaderStatic : public DispatchLoaderBase
-{
-public:
-	//=== VK_VERSION_1_0 ===
-
-	VkResult
-	vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateInstance(pCreateInfo, pAllocator, pInstance);
-	}
-
-	void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyInstance(instance, pAllocator);
-	}
-
-	VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
-	}
-
-	void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-	}
-
-	void
-	vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
-	}
-
-	VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,
-	                                                  VkFormat format,
-	                                                  VkImageType type,
-	                                                  VkImageTiling tiling,
-	                                                  VkImageUsageFlags usage,
-	                                                  VkImageCreateFlags flags,
-	                                                  VkImageFormatProperties *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-	}
-
-	void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
-	}
-
-	void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
-	                                              uint32_t *pQueueFamilyPropertyCount,
-	                                              VkQueueFamilyProperties *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-	}
-
-	void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
-	}
-
-	PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char *pName) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetInstanceProcAddr(instance, pName);
-	}
-
-	PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char *pName) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceProcAddr(device, pName);
-	}
-
-	VkResult vkCreateDevice(VkPhysicalDevice physicalDevice,
-	                        const VkDeviceCreateInfo *pCreateInfo,
-	                        const VkAllocationCallbacks *pAllocator,
-	                        VkDevice *pDevice) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
-	}
-
-	void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDevice(device, pAllocator);
-	}
-
-	VkResult vkEnumerateInstanceExtensionProperties(const char *pLayerName,
-	                                                uint32_t *pPropertyCount,
-	                                                VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
-	}
-
-	VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-	                                              const char *pLayerName,
-	                                              uint32_t *pPropertyCount,
-	                                              VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
-	}
-
-	VkResult vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
-	}
-
-	VkResult
-	vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
-	}
-
-	void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
-	}
-
-	VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueSubmit(queue, submitCount, pSubmits, fence);
-	}
-
-	VkResult vkQueueWaitIdle(VkQueue queue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueWaitIdle(queue);
-	}
-
-	VkResult vkDeviceWaitIdle(VkDevice device) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDeviceWaitIdle(device);
-	}
-
-	VkResult vkAllocateMemory(VkDevice device,
-	                          const VkMemoryAllocateInfo *pAllocateInfo,
-	                          const VkAllocationCallbacks *pAllocator,
-	                          VkDeviceMemory *pMemory) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
-	}
-
-	void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkFreeMemory(device, memory, pAllocator);
-	}
-
-	VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkMapMemory(device, memory, offset, size, flags, ppData);
-	}
-
-	void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkUnmapMemory(device, memory);
-	}
-
-	VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-	}
-
-	VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-	}
-
-	void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-	}
-
-	VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindBufferMemory(device, buffer, memory, memoryOffset);
-	}
-
-	VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindImageMemory(device, image, memory, memoryOffset);
-	}
-
-	void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-	}
-
-	void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
-	}
-
-	void vkGetImageSparseMemoryRequirements(VkDevice device,
-	                                        VkImage image,
-	                                        uint32_t *pSparseMemoryRequirementCount,
-	                                        VkSparseImageMemoryRequirements *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-	}
-
-	void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,
-	                                                    VkFormat format,
-	                                                    VkImageType type,
-	                                                    VkSampleCountFlagBits samples,
-	                                                    VkImageUsageFlags usage,
-	                                                    VkImageTiling tiling,
-	                                                    uint32_t *pPropertyCount,
-	                                                    VkSparseImageFormatProperties *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-	}
-
-	VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
-	}
-
-	VkResult vkCreateFence(VkDevice device,
-	                       const VkFenceCreateInfo *pCreateInfo,
-	                       const VkAllocationCallbacks *pAllocator,
-	                       VkFence *pFence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateFence(device, pCreateInfo, pAllocator, pFence);
-	}
-
-	void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyFence(device, fence, pAllocator);
-	}
-
-	VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkResetFences(device, fenceCount, pFences);
-	}
-
-	VkResult vkGetFenceStatus(VkDevice device, VkFence fence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetFenceStatus(device, fence);
-	}
-
-	VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
-	}
-
-	VkResult vkCreateSemaphore(VkDevice device,
-	                           const VkSemaphoreCreateInfo *pCreateInfo,
-	                           const VkAllocationCallbacks *pAllocator,
-	                           VkSemaphore *pSemaphore) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
-	}
-
-	void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroySemaphore(device, semaphore, pAllocator);
-	}
-
-	VkResult vkCreateEvent(VkDevice device,
-	                       const VkEventCreateInfo *pCreateInfo,
-	                       const VkAllocationCallbacks *pAllocator,
-	                       VkEvent *pEvent) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
-	}
-
-	void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyEvent(device, event, pAllocator);
-	}
-
-	VkResult vkGetEventStatus(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetEventStatus(device, event);
-	}
-
-	VkResult vkSetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetEvent(device, event);
-	}
-
-	VkResult vkResetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkResetEvent(device, event);
-	}
-
-	VkResult vkCreateQueryPool(VkDevice device,
-	                           const VkQueryPoolCreateInfo *pCreateInfo,
-	                           const VkAllocationCallbacks *pAllocator,
-	                           VkQueryPool *pQueryPool) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
-	}
-
-	void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyQueryPool(device, queryPool, pAllocator);
-	}
-
-	VkResult vkGetQueryPoolResults(VkDevice device,
-	                               VkQueryPool queryPool,
-	                               uint32_t firstQuery,
-	                               uint32_t queryCount,
-	                               size_t dataSize,
-	                               void *pData,
-	                               VkDeviceSize stride,
-	                               VkQueryResultFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-	}
-
-	VkResult vkCreateBuffer(VkDevice device,
-	                        const VkBufferCreateInfo *pCreateInfo,
-	                        const VkAllocationCallbacks *pAllocator,
-	                        VkBuffer *pBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
-	}
-
-	void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyBuffer(device, buffer, pAllocator);
-	}
-
-	VkResult vkCreateBufferView(VkDevice device,
-	                            const VkBufferViewCreateInfo *pCreateInfo,
-	                            const VkAllocationCallbacks *pAllocator,
-	                            VkBufferView *pView) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
-	}
-
-	void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyBufferView(device, bufferView, pAllocator);
-	}
-
-	VkResult vkCreateImage(VkDevice device,
-	                       const VkImageCreateInfo *pCreateInfo,
-	                       const VkAllocationCallbacks *pAllocator,
-	                       VkImage *pImage) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateImage(device, pCreateInfo, pAllocator, pImage);
-	}
-
-	void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyImage(device, image, pAllocator);
-	}
-
-	void vkGetImageSubresourceLayout(VkDevice device,
-	                                 VkImage image,
-	                                 const VkImageSubresource *pSubresource,
-	                                 VkSubresourceLayout *pLayout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
-	}
-
-	VkResult vkCreateImageView(VkDevice device,
-	                           const VkImageViewCreateInfo *pCreateInfo,
-	                           const VkAllocationCallbacks *pAllocator,
-	                           VkImageView *pView) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateImageView(device, pCreateInfo, pAllocator, pView);
-	}
-
-	void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyImageView(device, imageView, pAllocator);
-	}
-
-	VkResult vkCreateShaderModule(VkDevice device,
-	                              const VkShaderModuleCreateInfo *pCreateInfo,
-	                              const VkAllocationCallbacks *pAllocator,
-	                              VkShaderModule *pShaderModule) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
-	}
-
-	void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyShaderModule(device, shaderModule, pAllocator);
-	}
-
-	VkResult vkCreatePipelineCache(VkDevice device,
-	                               const VkPipelineCacheCreateInfo *pCreateInfo,
-	                               const VkAllocationCallbacks *pAllocator,
-	                               VkPipelineCache *pPipelineCache) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
-	}
-
-	void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyPipelineCache(device, pipelineCache, pAllocator);
-	}
-
-	VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-	}
-
-	VkResult
-	vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
-	}
-
-	VkResult vkCreateGraphicsPipelines(VkDevice device,
-	                                   VkPipelineCache pipelineCache,
-	                                   uint32_t createInfoCount,
-	                                   const VkGraphicsPipelineCreateInfo *pCreateInfos,
-	                                   const VkAllocationCallbacks *pAllocator,
-	                                   VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-	}
-
-	VkResult vkCreateComputePipelines(VkDevice device,
-	                                  VkPipelineCache pipelineCache,
-	                                  uint32_t createInfoCount,
-	                                  const VkComputePipelineCreateInfo *pCreateInfos,
-	                                  const VkAllocationCallbacks *pAllocator,
-	                                  VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-	}
-
-	void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyPipeline(device, pipeline, pAllocator);
-	}
-
-	VkResult vkCreatePipelineLayout(VkDevice device,
-	                                const VkPipelineLayoutCreateInfo *pCreateInfo,
-	                                const VkAllocationCallbacks *pAllocator,
-	                                VkPipelineLayout *pPipelineLayout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
-	}
-
-	void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
-	}
-
-	VkResult vkCreateSampler(VkDevice device,
-	                         const VkSamplerCreateInfo *pCreateInfo,
-	                         const VkAllocationCallbacks *pAllocator,
-	                         VkSampler *pSampler) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
-	}
-
-	void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroySampler(device, sampler, pAllocator);
-	}
-
-	VkResult vkCreateDescriptorSetLayout(VkDevice device,
-	                                     const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-	                                     const VkAllocationCallbacks *pAllocator,
-	                                     VkDescriptorSetLayout *pSetLayout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
-	}
-
-	void vkDestroyDescriptorSetLayout(VkDevice device,
-	                                  VkDescriptorSetLayout descriptorSetLayout,
-	                                  const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-	}
-
-	VkResult vkCreateDescriptorPool(VkDevice device,
-	                                const VkDescriptorPoolCreateInfo *pCreateInfo,
-	                                const VkAllocationCallbacks *pAllocator,
-	                                VkDescriptorPool *pDescriptorPool) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
-	}
-
-	void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
-	}
-
-	VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkResetDescriptorPool(device, descriptorPool, flags);
-	}
-
-	VkResult vkAllocateDescriptorSets(VkDevice device,
-	                                  const VkDescriptorSetAllocateInfo *pAllocateInfo,
-	                                  VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
-	}
-
-	VkResult vkFreeDescriptorSets(VkDevice device,
-	                              VkDescriptorPool descriptorPool,
-	                              uint32_t descriptorSetCount,
-	                              const VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
-	}
-
-	void vkUpdateDescriptorSets(VkDevice device,
-	                            uint32_t descriptorWriteCount,
-	                            const VkWriteDescriptorSet *pDescriptorWrites,
-	                            uint32_t descriptorCopyCount,
-	                            const VkCopyDescriptorSet *pDescriptorCopies) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-	}
-
-	VkResult vkCreateFramebuffer(VkDevice device,
-	                             const VkFramebufferCreateInfo *pCreateInfo,
-	                             const VkAllocationCallbacks *pAllocator,
-	                             VkFramebuffer *pFramebuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
-	}
-
-	void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyFramebuffer(device, framebuffer, pAllocator);
-	}
-
-	VkResult vkCreateRenderPass(VkDevice device,
-	                            const VkRenderPassCreateInfo *pCreateInfo,
-	                            const VkAllocationCallbacks *pAllocator,
-	                            VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
-	}
-
-	void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyRenderPass(device, renderPass, pAllocator);
-	}
-
-	void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetRenderAreaGranularity(device, renderPass, pGranularity);
-	}
-
-	VkResult vkCreateCommandPool(VkDevice device,
-	                             const VkCommandPoolCreateInfo *pCreateInfo,
-	                             const VkAllocationCallbacks *pAllocator,
-	                             VkCommandPool *pCommandPool) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
-	}
-
-	void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyCommandPool(device, commandPool, pAllocator);
-	}
-
-	VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkResetCommandPool(device, commandPool, flags);
-	}
-
-	VkResult vkAllocateCommandBuffers(VkDevice device,
-	                                  const VkCommandBufferAllocateInfo *pAllocateInfo,
-	                                  VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
-	}
-
-	void vkFreeCommandBuffers(VkDevice device,
-	                          VkCommandPool commandPool,
-	                          uint32_t commandBufferCount,
-	                          const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
-	}
-
-	VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBeginCommandBuffer(commandBuffer, pBeginInfo);
-	}
-
-	VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEndCommandBuffer(commandBuffer);
-	}
-
-	VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkResetCommandBuffer(commandBuffer, flags);
-	}
-
-	void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-	}
-
-	void
-	vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
-	}
-
-	void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
-	}
-
-	void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetLineWidth(commandBuffer, lineWidth);
-	}
-
-	void vkCmdSetDepthBias(VkCommandBuffer commandBuffer,
-	                       float depthBiasConstantFactor,
-	                       float depthBiasClamp,
-	                       float depthBiasSlopeFactor) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-	}
-
-	void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetBlendConstants(commandBuffer, blendConstants);
-	}
-
-	void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-	}
-
-	void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-	}
-
-	void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-	}
-
-	void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetStencilReference(commandBuffer, faceMask, reference);
-	}
-
-	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 VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindDescriptorSets(
-		    commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-	}
-
-	void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-	}
-
-	void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer,
-	                            uint32_t firstBinding,
-	                            uint32_t bindingCount,
-	                            const VkBuffer *pBuffers,
-	                            const VkDeviceSize *pOffsets) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-	}
-
-	void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		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 VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-	}
-
-	void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
-	}
-
-	void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
-	}
-
-	void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
-	}
-
-	void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDispatchIndirect(commandBuffer, buffer, offset);
-	}
-
-	void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-	}
-
-	void vkCmdCopyImage(VkCommandBuffer commandBuffer,
-	                    VkImage srcImage,
-	                    VkImageLayout srcImageLayout,
-	                    VkImage dstImage,
-	                    VkImageLayout dstImageLayout,
-	                    uint32_t regionCount,
-	                    const VkImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-	}
-
-	void vkCmdBlitImage(VkCommandBuffer commandBuffer,
-	                    VkImage srcImage,
-	                    VkImageLayout srcImageLayout,
-	                    VkImage dstImage,
-	                    VkImageLayout dstImageLayout,
-	                    uint32_t regionCount,
-	                    const VkImageBlit *pRegions,
-	                    VkFilter filter) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-	}
-
-	void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
-	                            VkBuffer srcBuffer,
-	                            VkImage dstImage,
-	                            VkImageLayout dstImageLayout,
-	                            uint32_t regionCount,
-	                            const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-	}
-
-	void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
-	                            VkImage srcImage,
-	                            VkImageLayout srcImageLayout,
-	                            VkBuffer dstBuffer,
-	                            uint32_t regionCount,
-	                            const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-	}
-
-	void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-	}
-
-	void
-	vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
-	}
-
-	void vkCmdClearColorImage(VkCommandBuffer commandBuffer,
-	                          VkImage image,
-	                          VkImageLayout imageLayout,
-	                          const VkClearColorValue *pColor,
-	                          uint32_t rangeCount,
-	                          const VkImageSubresourceRange *pRanges) const VULKAN_HPP_NOEXCEPT
-	{
-		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 VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-	}
-
-	void vkCmdClearAttachments(VkCommandBuffer commandBuffer,
-	                           uint32_t attachmentCount,
-	                           const VkClearAttachment *pAttachments,
-	                           uint32_t rectCount,
-	                           const VkClearRect *pRects) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-	}
-
-	void vkCmdResolveImage(VkCommandBuffer commandBuffer,
-	                       VkImage srcImage,
-	                       VkImageLayout srcImageLayout,
-	                       VkImage dstImage,
-	                       VkImageLayout dstImageLayout,
-	                       uint32_t regionCount,
-	                       const VkImageResolve *pRegions) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-	}
-
-	void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetEvent(commandBuffer, event, stageMask);
-	}
-
-	void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdResetEvent(commandBuffer, event, stageMask);
-	}
-
-	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 VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWaitEvents(commandBuffer,
-		                         eventCount,
-		                         pEvents,
-		                         srcStageMask,
-		                         dstStageMask,
-		                         memoryBarrierCount,
-		                         pMemoryBarriers,
-		                         bufferMemoryBarrierCount,
-		                         pBufferMemoryBarriers,
-		                         imageMemoryBarrierCount,
-		                         pImageMemoryBarriers);
-	}
-
-	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 VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdPipelineBarrier(commandBuffer,
-		                              srcStageMask,
-		                              dstStageMask,
-		                              dependencyFlags,
-		                              memoryBarrierCount,
-		                              pMemoryBarriers,
-		                              bufferMemoryBarrierCount,
-		                              pBufferMemoryBarriers,
-		                              imageMemoryBarrierCount,
-		                              pImageMemoryBarriers);
-	}
-
-	void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
-	}
-
-	void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndQuery(commandBuffer, queryPool, query);
-	}
-
-	void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
-	}
-
-	void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
-	                         VkPipelineStageFlagBits pipelineStage,
-	                         VkQueryPool queryPool,
-	                         uint32_t query) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
-	}
-
-	void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
-	                               VkQueryPool queryPool,
-	                               uint32_t firstQuery,
-	                               uint32_t queryCount,
-	                               VkBuffer dstBuffer,
-	                               VkDeviceSize dstOffset,
-	                               VkDeviceSize stride,
-	                               VkQueryResultFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-	}
-
-	void vkCmdPushConstants(VkCommandBuffer commandBuffer,
-	                        VkPipelineLayout layout,
-	                        VkShaderStageFlags stageFlags,
-	                        uint32_t offset,
-	                        uint32_t size,
-	                        const void *pValues) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
-	}
-
-	void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
-	                          const VkRenderPassBeginInfo *pRenderPassBegin,
-	                          VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
-	}
-
-	void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdNextSubpass(commandBuffer, contents);
-	}
-
-	void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndRenderPass(commandBuffer);
-	}
-
-	void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
-	}
-
-	//=== VK_VERSION_1_1 ===
-
-	VkResult vkEnumerateInstanceVersion(uint32_t *pApiVersion) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumerateInstanceVersion(pApiVersion);
-	}
-
-	VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
-	}
-
-	VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindImageMemory2(device, bindInfoCount, pBindInfos);
-	}
-
-	void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,
-	                                        uint32_t heapIndex,
-	                                        uint32_t localDeviceIndex,
-	                                        uint32_t remoteDeviceIndex,
-	                                        VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-	}
-
-	void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDeviceMask(commandBuffer, deviceMask);
-	}
-
-	void vkCmdDispatchBase(VkCommandBuffer commandBuffer,
-	                       uint32_t baseGroupX,
-	                       uint32_t baseGroupY,
-	                       uint32_t baseGroupZ,
-	                       uint32_t groupCountX,
-	                       uint32_t groupCountY,
-	                       uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-	}
-
-	VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance,
-	                                         uint32_t *pPhysicalDeviceGroupCount,
-	                                         VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-	}
-
-	void vkGetImageMemoryRequirements2(VkDevice device,
-	                                   const VkImageMemoryRequirementsInfo2 *pInfo,
-	                                   VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetBufferMemoryRequirements2(VkDevice device,
-	                                    const VkBufferMemoryRequirementsInfo2 *pInfo,
-	                                    VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetImageSparseMemoryRequirements2(VkDevice device,
-	                                         const VkImageSparseMemoryRequirementsInfo2 *pInfo,
-	                                         uint32_t *pSparseMemoryRequirementCount,
-	                                         VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-	}
-
-	void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
-	}
-
-	void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
-	}
-
-	void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
-	                                          VkFormat format,
-	                                          VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
-	}
-
-	VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,
-	                                                   const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
-	                                                   VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
-	}
-
-	void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
-	                                               uint32_t *pQueueFamilyPropertyCount,
-	                                               VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-	}
-
-	void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,
-	                                          VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
-	}
-
-	void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,
-	                                                     const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
-	                                                     uint32_t *pPropertyCount,
-	                                                     VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-	}
-
-	void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkTrimCommandPool(device, commandPool, flags);
-	}
-
-	void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceQueue2(device, pQueueInfo, pQueue);
-	}
-
-	VkResult vkCreateSamplerYcbcrConversion(VkDevice device,
-	                                        const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
-	                                        const VkAllocationCallbacks *pAllocator,
-	                                        VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
-	}
-
-	void vkDestroySamplerYcbcrConversion(VkDevice device,
-	                                     VkSamplerYcbcrConversion ycbcrConversion,
-	                                     const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
-	}
-
-	VkResult vkCreateDescriptorUpdateTemplate(VkDevice device,
-	                                          const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
-	                                          const VkAllocationCallbacks *pAllocator,
-	                                          VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-	}
-
-	void vkDestroyDescriptorUpdateTemplate(VkDevice device,
-	                                       VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-	                                       const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
-	}
-
-	void vkUpdateDescriptorSetWithTemplate(VkDevice device,
-	                                       VkDescriptorSet descriptorSet,
-	                                       VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-	                                       const void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
-	}
-
-	void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,
-	                                                 const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
-	                                                 VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-	}
-
-	void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,
-	                                                const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
-	                                                VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-	}
-
-	void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,
-	                                                    const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
-	                                                    VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-	}
-
-	void vkGetDescriptorSetLayoutSupport(VkDevice device,
-	                                     const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-	                                     VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
-	}
-
-	//=== VK_VERSION_1_2 ===
-
-	void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer,
-	                            VkBuffer buffer,
-	                            VkDeviceSize offset,
-	                            VkBuffer countBuffer,
-	                            VkDeviceSize countBufferOffset,
-	                            uint32_t maxDrawCount,
-	                            uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-	}
-
-	void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer,
-	                                   VkBuffer buffer,
-	                                   VkDeviceSize offset,
-	                                   VkBuffer countBuffer,
-	                                   VkDeviceSize countBufferOffset,
-	                                   uint32_t maxDrawCount,
-	                                   uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-	}
-
-	VkResult vkCreateRenderPass2(VkDevice device,
-	                             const VkRenderPassCreateInfo2 *pCreateInfo,
-	                             const VkAllocationCallbacks *pAllocator,
-	                             VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
-	}
-
-	void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
-	                           const VkRenderPassBeginInfo *pRenderPassBegin,
-	                           const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-	}
-
-	void vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
-	                       const VkSubpassBeginInfo *pSubpassBeginInfo,
-	                       const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-	}
-
-	void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
-	}
-
-	void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkResetQueryPool(device, queryPool, firstQuery, queryCount);
-	}
-
-	VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSemaphoreCounterValue(device, semaphore, pValue);
-	}
-
-	VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkWaitSemaphores(device, pWaitInfo, timeout);
-	}
-
-	VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSignalSemaphore(device, pSignalInfo);
-	}
-
-	VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferDeviceAddress(device, pInfo);
-	}
-
-	uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferOpaqueCaptureAddress(device, pInfo);
-	}
-
-	uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
-	}
-
-	//=== VK_VERSION_1_3 ===
-
-	VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice,
-	                                           uint32_t *pToolCount,
-	                                           VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties);
-	}
-
-	VkResult vkCreatePrivateDataSlot(VkDevice device,
-	                                 const VkPrivateDataSlotCreateInfo *pCreateInfo,
-	                                 const VkAllocationCallbacks *pAllocator,
-	                                 VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
-	}
-
-	void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator);
-	}
-
-	VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data);
-	}
-
-	void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
-	}
-
-	void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetEvent2(commandBuffer, event, pDependencyInfo);
-	}
-
-	void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdResetEvent2(commandBuffer, event, stageMask);
-	}
-
-	void vkCmdWaitEvents2(VkCommandBuffer commandBuffer,
-	                      uint32_t eventCount,
-	                      const VkEvent *pEvents,
-	                      const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos);
-	}
-
-	void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo);
-	}
-
-	void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
-	}
-
-	VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueSubmit2(queue, submitCount, pSubmits, fence);
-	}
-
-	void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo);
-	}
-
-	void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyImage2(commandBuffer, pCopyImageInfo);
-	}
-
-	void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo);
-	}
-
-	void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo);
-	}
-
-	void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBlitImage2(commandBuffer, pBlitImageInfo);
-	}
-
-	void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdResolveImage2(commandBuffer, pResolveImageInfo);
-	}
-
-	void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginRendering(commandBuffer, pRenderingInfo);
-	}
-
-	void vkCmdEndRendering(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndRendering(commandBuffer);
-	}
-
-	void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetCullMode(commandBuffer, cullMode);
-	}
-
-	void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetFrontFace(commandBuffer, frontFace);
-	}
-
-	void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology);
-	}
-
-	void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports);
-	}
-
-	void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors);
-	}
-
-	void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer,
-	                             uint32_t firstBinding,
-	                             uint32_t bindingCount,
-	                             const VkBuffer *pBuffers,
-	                             const VkDeviceSize *pOffsets,
-	                             const VkDeviceSize *pSizes,
-	                             const VkDeviceSize *pStrides) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
-	}
-
-	void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable);
-	}
-
-	void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable);
-	}
-
-	void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp);
-	}
-
-	void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable);
-	}
-
-	void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable);
-	}
-
-	void vkCmdSetStencilOp(VkCommandBuffer commandBuffer,
-	                       VkStencilFaceFlags faceMask,
-	                       VkStencilOp failOp,
-	                       VkStencilOp passOp,
-	                       VkStencilOp depthFailOp,
-	                       VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
-	}
-
-	void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable);
-	}
-
-	void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable);
-	}
-
-	void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable);
-	}
-
-	void vkGetDeviceBufferMemoryRequirements(VkDevice device,
-	                                         const VkDeviceBufferMemoryRequirements *pInfo,
-	                                         VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetDeviceImageMemoryRequirements(VkDevice device,
-	                                        const VkDeviceImageMemoryRequirements *pInfo,
-	                                        VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetDeviceImageSparseMemoryRequirements(VkDevice device,
-	                                              const VkDeviceImageMemoryRequirements *pInfo,
-	                                              uint32_t *pSparseMemoryRequirementCount,
-	                                              VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-	}
-
-	//=== VK_KHR_surface ===
-
-	void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroySurfaceKHR(instance, surface, pAllocator);
-	}
-
-	VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
-	                                              uint32_t queueFamilyIndex,
-	                                              VkSurfaceKHR surface,
-	                                              VkBool32 *pSupported) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
-	}
-
-	VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
-	                                                   VkSurfaceKHR surface,
-	                                                   VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
-	}
-
-	VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
-	                                              VkSurfaceKHR surface,
-	                                              uint32_t *pSurfaceFormatCount,
-	                                              VkSurfaceFormatKHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-	}
-
-	VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
-	                                                   VkSurfaceKHR surface,
-	                                                   uint32_t *pPresentModeCount,
-	                                                   VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
-	}
-
-	//=== VK_KHR_swapchain ===
-
-	VkResult vkCreateSwapchainKHR(VkDevice device,
-	                              const VkSwapchainCreateInfoKHR *pCreateInfo,
-	                              const VkAllocationCallbacks *pAllocator,
-	                              VkSwapchainKHR *pSwapchain) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-	}
-
-	void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroySwapchainKHR(device, swapchain, pAllocator);
-	}
-
-	VkResult vkGetSwapchainImagesKHR(VkDevice device,
-	                                 VkSwapchainKHR swapchain,
-	                                 uint32_t *pSwapchainImageCount,
-	                                 VkImage *pSwapchainImages) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
-	}
-
-	VkResult vkAcquireNextImageKHR(
-	    VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
-	}
-
-	VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueuePresentKHR(queue, pPresentInfo);
-	}
-
-	VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device,
-	                                                VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
-	}
-
-	VkResult
-	vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
-	}
-
-	VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
-	                                                 VkSurfaceKHR surface,
-	                                                 uint32_t *pRectCount,
-	                                                 VkRect2D *pRects) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
-	}
-
-	VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
-	}
-
-	//=== VK_KHR_display ===
-
-	VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
-	                                                 uint32_t *pPropertyCount,
-	                                                 VkDisplayPropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
-	}
-
-	VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
-	                                                      uint32_t *pPropertyCount,
-	                                                      VkDisplayPlanePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
-	}
-
-	VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
-	                                               uint32_t planeIndex,
-	                                               uint32_t *pDisplayCount,
-	                                               VkDisplayKHR *pDisplays) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
-	}
-
-	VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
-	                                       VkDisplayKHR display,
-	                                       uint32_t *pPropertyCount,
-	                                       VkDisplayModePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
-	}
-
-	VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
-	                                VkDisplayKHR display,
-	                                const VkDisplayModeCreateInfoKHR *pCreateInfo,
-	                                const VkAllocationCallbacks *pAllocator,
-	                                VkDisplayModeKHR *pMode) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
-	}
-
-	VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
-	                                          VkDisplayModeKHR mode,
-	                                          uint32_t planeIndex,
-	                                          VkDisplayPlaneCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
-	}
-
-	VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
-	                                        const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-	                                        const VkAllocationCallbacks *pAllocator,
-	                                        VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	//=== VK_KHR_display_swapchain ===
-
-	VkResult vkCreateSharedSwapchainsKHR(VkDevice device,
-	                                     uint32_t swapchainCount,
-	                                     const VkSwapchainCreateInfoKHR *pCreateInfos,
-	                                     const VkAllocationCallbacks *pAllocator,
-	                                     VkSwapchainKHR *pSwapchains) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-	}
-
-#	if defined(VK_USE_PLATFORM_XLIB_KHR)
-	//=== VK_KHR_xlib_surface ===
-
-	VkResult vkCreateXlibSurfaceKHR(VkInstance instance,
-	                                const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-	                                const VkAllocationCallbacks *pAllocator,
-	                                VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-	                                                       uint32_t queueFamilyIndex,
-	                                                       Display *dpy,
-	                                                       VisualID visualID) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
-	}
-#	endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#	if defined(VK_USE_PLATFORM_XCB_KHR)
-	//=== VK_KHR_xcb_surface ===
-
-	VkResult vkCreateXcbSurfaceKHR(VkInstance instance,
-	                               const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-	                               const VkAllocationCallbacks *pAllocator,
-	                               VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-	                                                      uint32_t queueFamilyIndex,
-	                                                      xcb_connection_t *connection,
-	                                                      xcb_visualid_t visual_id) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
-	}
-#	endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#	if defined(VK_USE_PLATFORM_WAYLAND_KHR)
-	//=== VK_KHR_wayland_surface ===
-
-	VkResult vkCreateWaylandSurfaceKHR(VkInstance instance,
-	                                   const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-	                                   const VkAllocationCallbacks *pAllocator,
-	                                   VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-	                                                          uint32_t queueFamilyIndex,
-	                                                          struct wl_display *display) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
-	}
-#	endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
-	//=== VK_KHR_android_surface ===
-
-	VkResult vkCreateAndroidSurfaceKHR(VkInstance instance,
-	                                   const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
-	                                   const VkAllocationCallbacks *pAllocator,
-	                                   VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-	}
-#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	//=== VK_KHR_win32_surface ===
-
-	VkResult vkCreateWin32SurfaceKHR(VkInstance instance,
-	                                 const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-	                                 const VkAllocationCallbacks *pAllocator,
-	                                 VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
-	}
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-	//=== VK_EXT_debug_report ===
-
-	VkResult vkCreateDebugReportCallbackEXT(VkInstance instance,
-	                                        const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-	                                        const VkAllocationCallbacks *pAllocator,
-	                                        VkDebugReportCallbackEXT *pCallback) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
-	}
-
-	void vkDestroyDebugReportCallbackEXT(VkInstance instance,
-	                                     VkDebugReportCallbackEXT callback,
-	                                     const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
-	}
-
-	void vkDebugReportMessageEXT(VkInstance instance,
-	                             VkDebugReportFlagsEXT flags,
-	                             VkDebugReportObjectTypeEXT objectType,
-	                             uint64_t object,
-	                             size_t location,
-	                             int32_t messageCode,
-	                             const char *pLayerPrefix,
-	                             const char *pMessage) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
-	}
-
-	//=== VK_EXT_debug_marker ===
-
-	VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
-	}
-
-	VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
-	}
-
-	void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
-	}
-
-	void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDebugMarkerEndEXT(commandBuffer);
-	}
-
-	void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
-	}
-
-#	if defined(VK_ENABLE_BETA_EXTENSIONS)
-	//=== VK_KHR_video_queue ===
-
-	VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
-	                                                 const VkVideoProfileKHR *pVideoProfile,
-	                                                 VkVideoCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities);
-	}
-
-	VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice,
-	                                                     const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo,
-	                                                     uint32_t *pVideoFormatPropertyCount,
-	                                                     VkVideoFormatPropertiesKHR *pVideoFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
-	}
-
-	VkResult vkCreateVideoSessionKHR(VkDevice device,
-	                                 const VkVideoSessionCreateInfoKHR *pCreateInfo,
-	                                 const VkAllocationCallbacks *pAllocator,
-	                                 VkVideoSessionKHR *pVideoSession) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession);
-	}
-
-	void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyVideoSessionKHR(device, videoSession, pAllocator);
-	}
-
-	VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device,
-	                                                VkVideoSessionKHR videoSession,
-	                                                uint32_t *pVideoSessionMemoryRequirementsCount,
-	                                                VkVideoGetMemoryPropertiesKHR *pVideoSessionMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements);
-	}
-
-	VkResult vkBindVideoSessionMemoryKHR(VkDevice device,
-	                                     VkVideoSessionKHR videoSession,
-	                                     uint32_t videoSessionBindMemoryCount,
-	                                     const VkVideoBindMemoryKHR *pVideoSessionBindMemories) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories);
-	}
-
-	VkResult vkCreateVideoSessionParametersKHR(VkDevice device,
-	                                           const VkVideoSessionParametersCreateInfoKHR *pCreateInfo,
-	                                           const VkAllocationCallbacks *pAllocator,
-	                                           VkVideoSessionParametersKHR *pVideoSessionParameters) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters);
-	}
-
-	VkResult vkUpdateVideoSessionParametersKHR(VkDevice device,
-	                                           VkVideoSessionParametersKHR videoSessionParameters,
-	                                           const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
-	}
-
-	void vkDestroyVideoSessionParametersKHR(VkDevice device,
-	                                        VkVideoSessionParametersKHR videoSessionParameters,
-	                                        const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator);
-	}
-
-	void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo);
-	}
-
-	void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo);
-	}
-
-	void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo);
-	}
-#	endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#	if defined(VK_ENABLE_BETA_EXTENSIONS)
-	//=== VK_KHR_video_decode_queue ===
-
-	void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pFrameInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDecodeVideoKHR(commandBuffer, pFrameInfo);
-	}
-#	endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-	//=== VK_EXT_transform_feedback ===
-
-	void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
-	                                          uint32_t firstBinding,
-	                                          uint32_t bindingCount,
-	                                          const VkBuffer *pBuffers,
-	                                          const VkDeviceSize *pOffsets,
-	                                          const VkDeviceSize *pSizes) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-	}
-
-	void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
-	                                    uint32_t firstCounterBuffer,
-	                                    uint32_t counterBufferCount,
-	                                    const VkBuffer *pCounterBuffers,
-	                                    const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-	}
-
-	void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
-	                                  uint32_t firstCounterBuffer,
-	                                  uint32_t counterBufferCount,
-	                                  const VkBuffer *pCounterBuffers,
-	                                  const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-	}
-
-	void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
-	}
-
-	void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
-	}
-
-	void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
-	                                   uint32_t instanceCount,
-	                                   uint32_t firstInstance,
-	                                   VkBuffer counterBuffer,
-	                                   VkDeviceSize counterBufferOffset,
-	                                   uint32_t counterOffset,
-	                                   uint32_t vertexStride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-	}
-
-	//=== VK_NVX_binary_import ===
-
-	VkResult vkCreateCuModuleNVX(VkDevice device,
-	                             const VkCuModuleCreateInfoNVX *pCreateInfo,
-	                             const VkAllocationCallbacks *pAllocator,
-	                             VkCuModuleNVX *pModule) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule);
-	}
-
-	VkResult vkCreateCuFunctionNVX(VkDevice device,
-	                               const VkCuFunctionCreateInfoNVX *pCreateInfo,
-	                               const VkAllocationCallbacks *pAllocator,
-	                               VkCuFunctionNVX *pFunction) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction);
-	}
-
-	void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyCuModuleNVX(device, module, pAllocator);
-	}
-
-	void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyCuFunctionNVX(device, function, pAllocator);
-	}
-
-	void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo);
-	}
-
-	//=== VK_NVX_image_view_handle ===
-
-	uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageViewHandleNVX(device, pInfo);
-	}
-
-	VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageViewAddressNVX(device, imageView, pProperties);
-	}
-
-	//=== VK_AMD_draw_indirect_count ===
-
-	void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer,
-	                               VkBuffer buffer,
-	                               VkDeviceSize offset,
-	                               VkBuffer countBuffer,
-	                               VkDeviceSize countBufferOffset,
-	                               uint32_t maxDrawCount,
-	                               uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-	}
-
-	void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer,
-	                                      VkBuffer buffer,
-	                                      VkDeviceSize offset,
-	                                      VkBuffer countBuffer,
-	                                      VkDeviceSize countBufferOffset,
-	                                      uint32_t maxDrawCount,
-	                                      uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-	}
-
-	//=== VK_AMD_shader_info ===
-
-	VkResult vkGetShaderInfoAMD(VkDevice device,
-	                            VkPipeline pipeline,
-	                            VkShaderStageFlagBits shaderStage,
-	                            VkShaderInfoTypeAMD infoType,
-	                            size_t *pInfoSize,
-	                            void *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
-	}
-
-	//=== VK_KHR_dynamic_rendering ===
-
-	void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo);
-	}
-
-	void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndRenderingKHR(commandBuffer);
-	}
-
-#	if defined(VK_USE_PLATFORM_GGP)
-	//=== VK_GGP_stream_descriptor_surface ===
-
-	VkResult vkCreateStreamDescriptorSurfaceGGP(VkInstance instance,
-	                                            const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo,
-	                                            const VkAllocationCallbacks *pAllocator,
-	                                            VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface);
-	}
-#	endif /*VK_USE_PLATFORM_GGP*/
-
-	//=== VK_NV_external_memory_capabilities ===
-
-	VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice,
-	                                                            VkFormat format,
-	                                                            VkImageType type,
-	                                                            VkImageTiling tiling,
-	                                                            VkImageUsageFlags usage,
-	                                                            VkImageCreateFlags flags,
-	                                                            VkExternalMemoryHandleTypeFlagsNV externalHandleType,
-	                                                            VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
-		    physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
-	}
-
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	//=== VK_NV_external_memory_win32 ===
-
-	VkResult vkGetMemoryWin32HandleNV(VkDevice device,
-	                                  VkDeviceMemory memory,
-	                                  VkExternalMemoryHandleTypeFlagsNV handleType,
-	                                  HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
-	}
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-	//=== VK_KHR_get_physical_device_properties2 ===
-
-	void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
-	}
-
-	void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
-	}
-
-	void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                             VkFormat format,
-	                                             VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
-	}
-
-	VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                                      const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
-	                                                      VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
-	}
-
-	void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                                  uint32_t *pQueueFamilyPropertyCount,
-	                                                  VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-	}
-
-	void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                             VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
-	}
-
-	void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                                        const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
-	                                                        uint32_t *pPropertyCount,
-	                                                        VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-	}
-
-	//=== VK_KHR_device_group ===
-
-	void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device,
-	                                           uint32_t heapIndex,
-	                                           uint32_t localDeviceIndex,
-	                                           uint32_t remoteDeviceIndex,
-	                                           VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-	}
-
-	void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
-	}
-
-	void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer,
-	                          uint32_t baseGroupX,
-	                          uint32_t baseGroupY,
-	                          uint32_t baseGroupZ,
-	                          uint32_t groupCountX,
-	                          uint32_t groupCountY,
-	                          uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-	}
-
-#	if defined(VK_USE_PLATFORM_VI_NN)
-	//=== VK_NN_vi_surface ===
-
-	VkResult vkCreateViSurfaceNN(VkInstance instance,
-	                             const VkViSurfaceCreateInfoNN *pCreateInfo,
-	                             const VkAllocationCallbacks *pAllocator,
-	                             VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
-	}
-#	endif /*VK_USE_PLATFORM_VI_NN*/
-
-	//=== VK_KHR_maintenance1 ===
-
-	void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkTrimCommandPoolKHR(device, commandPool, flags);
-	}
-
-	//=== VK_KHR_device_group_creation ===
-
-	VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,
-	                                            uint32_t *pPhysicalDeviceGroupCount,
-	                                            VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-	}
-
-	//=== VK_KHR_external_memory_capabilities ===
-
-	void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice,
-	                                                    const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
-	                                                    VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-	}
-
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	//=== VK_KHR_external_memory_win32 ===
-
-	VkResult vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-	}
-
-	VkResult vkGetMemoryWin32HandlePropertiesKHR(VkDevice device,
-	                                             VkExternalMemoryHandleTypeFlagBits handleType,
-	                                             HANDLE handle,
-	                                             VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
-	}
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-	//=== VK_KHR_external_memory_fd ===
-
-	VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
-	}
-
-	VkResult vkGetMemoryFdPropertiesKHR(VkDevice device,
-	                                    VkExternalMemoryHandleTypeFlagBits handleType,
-	                                    int fd,
-	                                    VkMemoryFdPropertiesKHR *pMemoryFdProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
-	}
-
-	//=== VK_KHR_external_semaphore_capabilities ===
-
-	void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice,
-	                                                       const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
-	                                                       VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-	}
-
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	//=== VK_KHR_external_semaphore_win32 ===
-
-	VkResult vkImportSemaphoreWin32HandleKHR(VkDevice device,
-	                                         const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
-	}
-
-	VkResult
-	vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-	}
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-	//=== VK_KHR_external_semaphore_fd ===
-
-	VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
-	}
-
-	VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd);
-	}
-
-	//=== VK_KHR_push_descriptor ===
-
-	void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
-	                               VkPipelineBindPoint pipelineBindPoint,
-	                               VkPipelineLayout layout,
-	                               uint32_t set,
-	                               uint32_t descriptorWriteCount,
-	                               const VkWriteDescriptorSet *pDescriptorWrites) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-	}
-
-	void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
-	                                           VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-	                                           VkPipelineLayout layout,
-	                                           uint32_t set,
-	                                           const void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-	}
-
-	//=== VK_EXT_conditional_rendering ===
-
-	void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer,
-	                                       const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
-	}
-
-	void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndConditionalRenderingEXT(commandBuffer);
-	}
-
-	//=== VK_KHR_descriptor_update_template ===
-
-	VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device,
-	                                             const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
-	                                             const VkAllocationCallbacks *pAllocator,
-	                                             VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-	}
-
-	void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device,
-	                                          VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-	                                          const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
-	}
-
-	void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device,
-	                                          VkDescriptorSet descriptorSet,
-	                                          VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-	                                          const void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
-	}
-
-	//=== VK_NV_clip_space_w_scaling ===
-
-	void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer,
-	                                uint32_t firstViewport,
-	                                uint32_t viewportCount,
-	                                const VkViewportWScalingNV *pViewportWScalings) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
-	}
-
-	//=== VK_EXT_direct_mode_display ===
-
-	VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkReleaseDisplayEXT(physicalDevice, display);
-	}
-
-#	if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
-	//=== VK_EXT_acquire_xlib_display ===
-
-	VkResult vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquireXlibDisplayEXT(physicalDevice, dpy, display);
-	}
-
-	VkResult vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
-	}
-#	endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-	//=== VK_EXT_display_surface_counter ===
-
-	VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
-	                                                    VkSurfaceKHR surface,
-	                                                    VkSurfaceCapabilities2EXT *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
-	}
-
-	//=== VK_EXT_display_control ===
-
-	VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
-	}
-
-	VkResult vkRegisterDeviceEventEXT(VkDevice device,
-	                                  const VkDeviceEventInfoEXT *pDeviceEventInfo,
-	                                  const VkAllocationCallbacks *pAllocator,
-	                                  VkFence *pFence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
-	}
-
-	VkResult vkRegisterDisplayEventEXT(VkDevice device,
-	                                   VkDisplayKHR display,
-	                                   const VkDisplayEventInfoEXT *pDisplayEventInfo,
-	                                   const VkAllocationCallbacks *pAllocator,
-	                                   VkFence *pFence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
-	}
-
-	VkResult vkGetSwapchainCounterEXT(VkDevice device,
-	                                  VkSwapchainKHR swapchain,
-	                                  VkSurfaceCounterFlagBitsEXT counter,
-	                                  uint64_t *pCounterValue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
-	}
-
-	//=== VK_GOOGLE_display_timing ===
-
-	VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device,
-	                                         VkSwapchainKHR swapchain,
-	                                         VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
-	}
-
-	VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device,
-	                                           VkSwapchainKHR swapchain,
-	                                           uint32_t *pPresentationTimingCount,
-	                                           VkPastPresentationTimingGOOGLE *pPresentationTimings) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
-	}
-
-	//=== VK_EXT_discard_rectangles ===
-
-	void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,
-	                                 uint32_t firstDiscardRectangle,
-	                                 uint32_t discardRectangleCount,
-	                                 const VkRect2D *pDiscardRectangles) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
-	}
-
-	//=== VK_EXT_hdr_metadata ===
-
-	void vkSetHdrMetadataEXT(VkDevice device,
-	                         uint32_t swapchainCount,
-	                         const VkSwapchainKHR *pSwapchains,
-	                         const VkHdrMetadataEXT *pMetadata) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
-	}
-
-	//=== VK_KHR_create_renderpass2 ===
-
-	VkResult vkCreateRenderPass2KHR(VkDevice device,
-	                                const VkRenderPassCreateInfo2 *pCreateInfo,
-	                                const VkAllocationCallbacks *pAllocator,
-	                                VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
-	}
-
-	void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
-	                              const VkRenderPassBeginInfo *pRenderPassBegin,
-	                              const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-	}
-
-	void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
-	                          const VkSubpassBeginInfo *pSubpassBeginInfo,
-	                          const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-	}
-
-	void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
-	}
-
-	//=== VK_KHR_shared_presentable_image ===
-
-	VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSwapchainStatusKHR(device, swapchain);
-	}
-
-	//=== VK_KHR_external_fence_capabilities ===
-
-	void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice,
-	                                                   const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
-	                                                   VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-	}
-
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	//=== VK_KHR_external_fence_win32 ===
-
-	VkResult vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
-	}
-
-	VkResult vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-	}
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-	//=== VK_KHR_external_fence_fd ===
-
-	VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkImportFenceFdKHR(device, pImportFenceFdInfo);
-	}
-
-	VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetFenceFdKHR(device, pGetFdInfo, pFd);
-	}
-
-	//=== VK_KHR_performance_query ===
-
-	VkResult
-	vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice,
-	                                                                uint32_t queueFamilyIndex,
-	                                                                uint32_t *pCounterCount,
-	                                                                VkPerformanceCounterKHR *pCounters,
-	                                                                VkPerformanceCounterDescriptionKHR *pCounterDescriptions) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-		    physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
-	}
-
-	void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice,
-	                                                             const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo,
-	                                                             uint32_t *pNumPasses) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
-	}
-
-	VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquireProfilingLockKHR(device, pInfo);
-	}
-
-	void vkReleaseProfilingLockKHR(VkDevice device) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkReleaseProfilingLockKHR(device);
-	}
-
-	//=== VK_KHR_get_surface_capabilities2 ===
-
-	VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
-	                                                    const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-	                                                    VkSurfaceCapabilities2KHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
-	}
-
-	VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
-	                                               const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-	                                               uint32_t *pSurfaceFormatCount,
-	                                               VkSurfaceFormat2KHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
-	}
-
-	//=== VK_KHR_get_display_properties2 ===
-
-	VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                                  uint32_t *pPropertyCount,
-	                                                  VkDisplayProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
-	}
-
-	VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                                       uint32_t *pPropertyCount,
-	                                                       VkDisplayPlaneProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
-	}
-
-	VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,
-	                                        VkDisplayKHR display,
-	                                        uint32_t *pPropertyCount,
-	                                        VkDisplayModeProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
-	}
-
-	VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
-	                                           const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
-	                                           VkDisplayPlaneCapabilities2KHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
-	}
-
-#	if defined(VK_USE_PLATFORM_IOS_MVK)
-	//=== VK_MVK_ios_surface ===
-
-	VkResult vkCreateIOSSurfaceMVK(VkInstance instance,
-	                               const VkIOSSurfaceCreateInfoMVK *pCreateInfo,
-	                               const VkAllocationCallbacks *pAllocator,
-	                               VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
-	}
-#	endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#	if defined(VK_USE_PLATFORM_MACOS_MVK)
-	//=== VK_MVK_macos_surface ===
-
-	VkResult vkCreateMacOSSurfaceMVK(VkInstance instance,
-	                                 const VkMacOSSurfaceCreateInfoMVK *pCreateInfo,
-	                                 const VkAllocationCallbacks *pAllocator,
-	                                 VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
-	}
-#	endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-	//=== VK_EXT_debug_utils ===
-
-	VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
-	}
-
-	VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
-	}
-
-	void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
-	}
-
-	void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueEndDebugUtilsLabelEXT(queue);
-	}
-
-	void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
-	}
-
-	void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
-	}
-
-	void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEndDebugUtilsLabelEXT(commandBuffer);
-	}
-
-	void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
-	}
-
-	VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance,
-	                                        const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
-	                                        const VkAllocationCallbacks *pAllocator,
-	                                        VkDebugUtilsMessengerEXT *pMessenger) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
-	}
-
-	void vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
-	                                     VkDebugUtilsMessengerEXT messenger,
-	                                     const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
-	}
-
-	void vkSubmitDebugUtilsMessageEXT(VkInstance instance,
-	                                  VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
-	                                  VkDebugUtilsMessageTypeFlagsEXT messageTypes,
-	                                  const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
-	}
-
-#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
-	//=== VK_ANDROID_external_memory_android_hardware_buffer ===
-
-	VkResult vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device,
-	                                                     const struct AHardwareBuffer *buffer,
-	                                                     VkAndroidHardwareBufferPropertiesANDROID *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
-	}
-
-	VkResult vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device,
-	                                                 const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo,
-	                                                 struct AHardwareBuffer **pBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
-	}
-#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-	//=== VK_EXT_sample_locations ===
-
-	void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
-	}
-
-	void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,
-	                                                 VkSampleCountFlagBits samples,
-	                                                 VkMultisamplePropertiesEXT *pMultisampleProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
-	}
-
-	//=== VK_KHR_get_memory_requirements2 ===
-
-	void vkGetImageMemoryRequirements2KHR(VkDevice device,
-	                                      const VkImageMemoryRequirementsInfo2 *pInfo,
-	                                      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetBufferMemoryRequirements2KHR(VkDevice device,
-	                                       const VkBufferMemoryRequirementsInfo2 *pInfo,
-	                                       VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetImageSparseMemoryRequirements2KHR(VkDevice device,
-	                                            const VkImageSparseMemoryRequirementsInfo2 *pInfo,
-	                                            uint32_t *pSparseMemoryRequirementCount,
-	                                            VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-	}
-
-	//=== VK_KHR_acceleration_structure ===
-
-	VkResult vkCreateAccelerationStructureKHR(VkDevice device,
-	                                          const VkAccelerationStructureCreateInfoKHR *pCreateInfo,
-	                                          const VkAllocationCallbacks *pAllocator,
-	                                          VkAccelerationStructureKHR *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
-	}
-
-	void vkDestroyAccelerationStructureKHR(VkDevice device,
-	                                       VkAccelerationStructureKHR accelerationStructure,
-	                                       const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
-	}
-
-	void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer,
-	                                         uint32_t infoCount,
-	                                         const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
-	                                         const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
-	}
-
-	void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer,
-	                                                 uint32_t infoCount,
-	                                                 const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
-	                                                 const VkDeviceAddress *pIndirectDeviceAddresses,
-	                                                 const uint32_t *pIndirectStrides,
-	                                                 const uint32_t *const *ppMaxPrimitiveCounts) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBuildAccelerationStructuresIndirectKHR(
-		    commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
-	}
-
-	VkResult vkBuildAccelerationStructuresKHR(VkDevice device,
-	                                          VkDeferredOperationKHR deferredOperation,
-	                                          uint32_t infoCount,
-	                                          const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
-	                                          const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
-	}
-
-	VkResult vkCopyAccelerationStructureKHR(VkDevice device,
-	                                        VkDeferredOperationKHR deferredOperation,
-	                                        const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo);
-	}
-
-	VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device,
-	                                                VkDeferredOperationKHR deferredOperation,
-	                                                const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
-	}
-
-	VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device,
-	                                                VkDeferredOperationKHR deferredOperation,
-	                                                const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
-	}
-
-	VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device,
-	                                                    uint32_t accelerationStructureCount,
-	                                                    const VkAccelerationStructureKHR *pAccelerationStructures,
-	                                                    VkQueryType queryType,
-	                                                    size_t dataSize,
-	                                                    void *pData,
-	                                                    size_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
-	}
-
-	void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
-	}
-
-	void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer,
-	                                               const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
-	}
-
-	void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer,
-	                                               const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
-	}
-
-	VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device,
-	                                                           const VkAccelerationStructureDeviceAddressInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetAccelerationStructureDeviceAddressKHR(device, pInfo);
-	}
-
-	void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer,
-	                                                   uint32_t accelerationStructureCount,
-	                                                   const VkAccelerationStructureKHR *pAccelerationStructures,
-	                                                   VkQueryType queryType,
-	                                                   VkQueryPool queryPool,
-	                                                   uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
-		    commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
-	}
-
-	void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device,
-	                                                      const VkAccelerationStructureVersionInfoKHR *pVersionInfo,
-	                                                      VkAccelerationStructureCompatibilityKHR *pCompatibility) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
-	}
-
-	void vkGetAccelerationStructureBuildSizesKHR(VkDevice device,
-	                                             VkAccelerationStructureBuildTypeKHR buildType,
-	                                             const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo,
-	                                             const uint32_t *pMaxPrimitiveCounts,
-	                                             VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
-	}
-
-	//=== VK_KHR_sampler_ycbcr_conversion ===
-
-	VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device,
-	                                           const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
-	                                           const VkAllocationCallbacks *pAllocator,
-	                                           VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
-	}
-
-	void vkDestroySamplerYcbcrConversionKHR(VkDevice device,
-	                                        VkSamplerYcbcrConversion ycbcrConversion,
-	                                        const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
-	}
-
-	//=== VK_KHR_bind_memory2 ===
-
-	VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
-	}
-
-	VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
-	}
-
-	//=== VK_EXT_image_drm_format_modifier ===
-
-	VkResult
-	vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
-	}
-
-	//=== VK_EXT_validation_cache ===
-
-	VkResult vkCreateValidationCacheEXT(VkDevice device,
-	                                    const VkValidationCacheCreateInfoEXT *pCreateInfo,
-	                                    const VkAllocationCallbacks *pAllocator,
-	                                    VkValidationCacheEXT *pValidationCache) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
-	}
-
-	void
-	vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
-	}
-
-	VkResult vkMergeValidationCachesEXT(VkDevice device,
-	                                    VkValidationCacheEXT dstCache,
-	                                    uint32_t srcCacheCount,
-	                                    const VkValidationCacheEXT *pSrcCaches) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
-	}
-
-	VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
-	}
-
-	//=== VK_NV_shading_rate_image ===
-
-	void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
-	}
-
-	void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer,
-	                                          uint32_t firstViewport,
-	                                          uint32_t viewportCount,
-	                                          const VkShadingRatePaletteNV *pShadingRatePalettes) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
-	}
-
-	void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
-	                                 VkCoarseSampleOrderTypeNV sampleOrderType,
-	                                 uint32_t customSampleOrderCount,
-	                                 const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
-	}
-
-	//=== VK_NV_ray_tracing ===
-
-	VkResult vkCreateAccelerationStructureNV(VkDevice device,
-	                                         const VkAccelerationStructureCreateInfoNV *pCreateInfo,
-	                                         const VkAllocationCallbacks *pAllocator,
-	                                         VkAccelerationStructureNV *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
-	}
-
-	void vkDestroyAccelerationStructureNV(VkDevice device,
-	                                      VkAccelerationStructureNV accelerationStructure,
-	                                      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
-	}
-
-	void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device,
-	                                                    const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo,
-	                                                    VkMemoryRequirements2KHR *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
-	}
-
-	VkResult vkBindAccelerationStructureMemoryNV(VkDevice device,
-	                                             uint32_t bindInfoCount,
-	                                             const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
-	}
-
-	void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
-	                                       const VkAccelerationStructureInfoNV *pInfo,
-	                                       VkBuffer instanceData,
-	                                       VkDeviceSize instanceOffset,
-	                                       VkBool32 update,
-	                                       VkAccelerationStructureNV dst,
-	                                       VkAccelerationStructureNV src,
-	                                       VkBuffer scratch,
-	                                       VkDeviceSize scratchOffset) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
-	}
-
-	void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
-	                                      VkAccelerationStructureNV dst,
-	                                      VkAccelerationStructureNV src,
-	                                      VkCopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
-	}
-
-	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 VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdTraceRaysNV(commandBuffer,
-		                          raygenShaderBindingTableBuffer,
-		                          raygenShaderBindingOffset,
-		                          missShaderBindingTableBuffer,
-		                          missShaderBindingOffset,
-		                          missShaderBindingStride,
-		                          hitShaderBindingTableBuffer,
-		                          hitShaderBindingOffset,
-		                          hitShaderBindingStride,
-		                          callableShaderBindingTableBuffer,
-		                          callableShaderBindingOffset,
-		                          callableShaderBindingStride,
-		                          width,
-		                          height,
-		                          depth);
-	}
-
-	VkResult vkCreateRayTracingPipelinesNV(VkDevice device,
-	                                       VkPipelineCache pipelineCache,
-	                                       uint32_t createInfoCount,
-	                                       const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
-	                                       const VkAllocationCallbacks *pAllocator,
-	                                       VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-	}
-
-	VkResult vkGetRayTracingShaderGroupHandlesNV(
-	    VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
-	}
-
-	VkResult vkGetAccelerationStructureHandleNV(VkDevice device,
-	                                            VkAccelerationStructureNV accelerationStructure,
-	                                            size_t dataSize,
-	                                            void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
-	}
-
-	void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer,
-	                                                  uint32_t accelerationStructureCount,
-	                                                  const VkAccelerationStructureNV *pAccelerationStructures,
-	                                                  VkQueryType queryType,
-	                                                  VkQueryPool queryPool,
-	                                                  uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWriteAccelerationStructuresPropertiesNV(
-		    commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
-	}
-
-	VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCompileDeferredNV(device, pipeline, shader);
-	}
-
-	//=== VK_KHR_maintenance3 ===
-
-	void vkGetDescriptorSetLayoutSupportKHR(VkDevice device,
-	                                        const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-	                                        VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
-	}
-
-	//=== VK_KHR_draw_indirect_count ===
-
-	void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer,
-	                               VkBuffer buffer,
-	                               VkDeviceSize offset,
-	                               VkBuffer countBuffer,
-	                               VkDeviceSize countBufferOffset,
-	                               uint32_t maxDrawCount,
-	                               uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndirectCountKHR(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 VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-	}
-
-	//=== VK_EXT_external_memory_host ===
-
-	VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device,
-	                                             VkExternalMemoryHandleTypeFlagBits handleType,
-	                                             const void *pHostPointer,
-	                                             VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
-	}
-
-	//=== VK_AMD_buffer_marker ===
-
-	void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
-	                               VkPipelineStageFlagBits pipelineStage,
-	                               VkBuffer dstBuffer,
-	                               VkDeviceSize dstOffset,
-	                               uint32_t marker) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
-	}
-
-	//=== VK_EXT_calibrated_timestamps ===
-
-	VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
-	                                                        uint32_t *pTimeDomainCount,
-	                                                        VkTimeDomainEXT *pTimeDomains) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
-	}
-
-	VkResult vkGetCalibratedTimestampsEXT(VkDevice device,
-	                                      uint32_t timestampCount,
-	                                      const VkCalibratedTimestampInfoEXT *pTimestampInfos,
-	                                      uint64_t *pTimestamps,
-	                                      uint64_t *pMaxDeviation) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
-	}
-
-	//=== VK_NV_mesh_shader ===
-
-	void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
-	}
-
-	void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
-	}
-
-	void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer,
-	                                       VkBuffer buffer,
-	                                       VkDeviceSize offset,
-	                                       VkBuffer countBuffer,
-	                                       VkDeviceSize countBufferOffset,
-	                                       uint32_t maxDrawCount,
-	                                       uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-	}
-
-	//=== VK_NV_scissor_exclusive ===
-
-	void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,
-	                                uint32_t firstExclusiveScissor,
-	                                uint32_t exclusiveScissorCount,
-	                                const VkRect2D *pExclusiveScissors) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
-	}
-
-	//=== VK_NV_device_diagnostic_checkpoints ===
-
-	void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
-	}
-
-	void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
-	}
-
-	//=== VK_KHR_timeline_semaphore ===
-
-	VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSemaphoreCounterValueKHR(device, semaphore, pValue);
-	}
-
-	VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkWaitSemaphoresKHR(device, pWaitInfo, timeout);
-	}
-
-	VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSignalSemaphoreKHR(device, pSignalInfo);
-	}
-
-	//=== VK_INTEL_performance_query ===
-
-	VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkInitializePerformanceApiINTEL(device, pInitializeInfo);
-	}
-
-	void vkUninitializePerformanceApiINTEL(VkDevice device) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkUninitializePerformanceApiINTEL(device);
-	}
-
-	VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
-	}
-
-	VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,
-	                                              const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
-	}
-
-	VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
-	}
-
-	VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device,
-	                                                const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo,
-	                                                VkPerformanceConfigurationINTEL *pConfiguration) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
-	}
-
-	VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkReleasePerformanceConfigurationINTEL(device, configuration);
-	}
-
-	VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueSetPerformanceConfigurationINTEL(queue, configuration);
-	}
-
-	VkResult
-	vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPerformanceParameterINTEL(device, parameter, pValue);
-	}
-
-	//=== VK_AMD_display_native_hdr ===
-
-	void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable);
-	}
-
-#	if defined(VK_USE_PLATFORM_FUCHSIA)
-	//=== VK_FUCHSIA_imagepipe_surface ===
-
-	VkResult vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance,
-	                                         const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo,
-	                                         const VkAllocationCallbacks *pAllocator,
-	                                         VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface);
-	}
-#	endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#	if defined(VK_USE_PLATFORM_METAL_EXT)
-	//=== VK_EXT_metal_surface ===
-
-	VkResult vkCreateMetalSurfaceEXT(VkInstance instance,
-	                                 const VkMetalSurfaceCreateInfoEXT *pCreateInfo,
-	                                 const VkAllocationCallbacks *pAllocator,
-	                                 VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
-	}
-#	endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-	//=== VK_KHR_fragment_shading_rate ===
-
-	VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice,
-	                                                    uint32_t *pFragmentShadingRateCount,
-	                                                    VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
-	}
-
-	void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,
-	                                    const VkExtent2D *pFragmentSize,
-	                                    const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
-	}
-
-	//=== VK_EXT_buffer_device_address ===
-
-	VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferDeviceAddressEXT(device, pInfo);
-	}
-
-	//=== VK_EXT_tooling_info ===
-
-	VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice,
-	                                              uint32_t *pToolCount,
-	                                              VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties);
-	}
-
-	//=== VK_KHR_present_wait ===
-
-	VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkWaitForPresentKHR(device, swapchain, presentId, timeout);
-	}
-
-	//=== VK_NV_cooperative_matrix ===
-
-	VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice,
-	                                                          uint32_t *pPropertyCount,
-	                                                          VkCooperativeMatrixPropertiesNV *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties);
-	}
-
-	//=== VK_NV_coverage_reduction_mode ===
-
-	VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-	    VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations);
-	}
-
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	//=== VK_EXT_full_screen_exclusive ===
-
-	VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice,
-	                                                    const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-	                                                    uint32_t *pPresentModeCount,
-	                                                    VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
-	}
-
-	VkResult vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquireFullScreenExclusiveModeEXT(device, swapchain);
-	}
-
-	VkResult vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkReleaseFullScreenExclusiveModeEXT(device, swapchain);
-	}
-
-	VkResult vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device,
-	                                                 const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-	                                                 VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes);
-	}
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-	//=== VK_EXT_headless_surface ===
-
-	VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance,
-	                                    const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo,
-	                                    const VkAllocationCallbacks *pAllocator,
-	                                    VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	//=== VK_KHR_buffer_device_address ===
-
-	VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferDeviceAddressKHR(device, pInfo);
-	}
-
-	uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferOpaqueCaptureAddressKHR(device, pInfo);
-	}
-
-	uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
-	}
-
-	//=== VK_EXT_line_rasterization ===
-
-	void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
-	}
-
-	//=== VK_EXT_host_query_reset ===
-
-	void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
-	}
-
-	//=== VK_EXT_extended_dynamic_state ===
-
-	void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetCullModeEXT(commandBuffer, cullMode);
-	}
-
-	void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetFrontFaceEXT(commandBuffer, frontFace);
-	}
-
-	void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology);
-	}
-
-	void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports);
-	}
-
-	void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors);
-	}
-
-	void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
-	                                uint32_t firstBinding,
-	                                uint32_t bindingCount,
-	                                const VkBuffer *pBuffers,
-	                                const VkDeviceSize *pOffsets,
-	                                const VkDeviceSize *pSizes,
-	                                const VkDeviceSize *pStrides) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
-	}
-
-	void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable);
-	}
-
-	void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable);
-	}
-
-	void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp);
-	}
-
-	void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable);
-	}
-
-	void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable);
-	}
-
-	void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
-	                          VkStencilFaceFlags faceMask,
-	                          VkStencilOp failOp,
-	                          VkStencilOp passOp,
-	                          VkStencilOp depthFailOp,
-	                          VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
-	}
-
-	//=== VK_KHR_deferred_host_operations ===
-
-	VkResult vkCreateDeferredOperationKHR(VkDevice device,
-	                                      const VkAllocationCallbacks *pAllocator,
-	                                      VkDeferredOperationKHR *pDeferredOperation) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation);
-	}
-
-	void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyDeferredOperationKHR(device, operation, pAllocator);
-	}
-
-	uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeferredOperationMaxConcurrencyKHR(device, operation);
-	}
-
-	VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeferredOperationResultKHR(device, operation);
-	}
-
-	VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDeferredOperationJoinKHR(device, operation);
-	}
-
-	//=== VK_KHR_pipeline_executable_properties ===
-
-	VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device,
-	                                              const VkPipelineInfoKHR *pPipelineInfo,
-	                                              uint32_t *pExecutableCount,
-	                                              VkPipelineExecutablePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
-	}
-
-	VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device,
-	                                              const VkPipelineExecutableInfoKHR *pExecutableInfo,
-	                                              uint32_t *pStatisticCount,
-	                                              VkPipelineExecutableStatisticKHR *pStatistics) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
-	}
-
-	VkResult
-	vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device,
-	                                                  const VkPipelineExecutableInfoKHR *pExecutableInfo,
-	                                                  uint32_t *pInternalRepresentationCount,
-	                                                  VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
-	}
-
-	//=== VK_NV_device_generated_commands ===
-
-	void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device,
-	                                                const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo,
-	                                                VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
-	}
-
-	void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer,
-	                                     VkBool32 isPreprocessed,
-	                                     const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
-	}
-
-	void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
-	                                    VkPipelineBindPoint pipelineBindPoint,
-	                                    VkPipeline pipeline,
-	                                    uint32_t groupIndex) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
-	}
-
-	VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device,
-	                                          const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo,
-	                                          const VkAllocationCallbacks *pAllocator,
-	                                          VkIndirectCommandsLayoutNV *pIndirectCommandsLayout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-	}
-
-	void vkDestroyIndirectCommandsLayoutNV(VkDevice device,
-	                                       VkIndirectCommandsLayoutNV indirectCommandsLayout,
-	                                       const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
-	}
-
-	//=== VK_EXT_acquire_drm_display ===
-
-	VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display);
-	}
-
-	VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display);
-	}
-
-	//=== VK_EXT_private_data ===
-
-	VkResult vkCreatePrivateDataSlotEXT(VkDevice device,
-	                                    const VkPrivateDataSlotCreateInfo *pCreateInfo,
-	                                    const VkAllocationCallbacks *pAllocator,
-	                                    VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot);
-	}
-
-	void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
-	}
-
-	VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data);
-	}
-
-	void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const
-	    VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData);
-	}
-
-#	if defined(VK_ENABLE_BETA_EXTENSIONS)
-	//=== VK_KHR_video_encode_queue ===
-
-	void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo);
-	}
-#	endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-	//=== VK_KHR_synchronization2 ===
-
-	void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
-	}
-
-	void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdResetEvent2KHR(commandBuffer, event, stageMask);
-	}
-
-	void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer,
-	                         uint32_t eventCount,
-	                         const VkEvent *pEvents,
-	                         const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos);
-	}
-
-	void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
-	}
-
-	void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
-	}
-
-	VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence);
-	}
-
-	void vkCmdWriteBufferMarker2AMD(
-	    VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
-	}
-
-	void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
-	}
-
-	//=== VK_NV_fragment_shading_rate_enums ===
-
-	void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,
-	                                       VkFragmentShadingRateNV shadingRate,
-	                                       const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
-	}
-
-	//=== VK_KHR_copy_commands2 ===
-
-	void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
-	}
-
-	void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
-	}
-
-	void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
-	}
-
-	void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
-	}
-
-	void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
-	}
-
-	void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
-	}
-
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	//=== VK_NV_acquire_winrt_display ===
-
-	VkResult vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkAcquireWinrtDisplayNV(physicalDevice, display);
-	}
-
-	VkResult vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay);
-	}
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#	if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
-	//=== VK_EXT_directfb_surface ===
-
-	VkResult vkCreateDirectFBSurfaceEXT(VkInstance instance,
-	                                    const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo,
-	                                    const VkAllocationCallbacks *pAllocator,
-	                                    VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	VkBool32
-	vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb);
-	}
-#	endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-	//=== VK_KHR_ray_tracing_pipeline ===
-
-	void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer,
-	                       const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable,
-	                       const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable,
-	                       const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable,
-	                       const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable,
-	                       uint32_t width,
-	                       uint32_t height,
-	                       uint32_t depth) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdTraceRaysKHR(
-		    commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
-	}
-
-	VkResult vkCreateRayTracingPipelinesKHR(VkDevice device,
-	                                        VkDeferredOperationKHR deferredOperation,
-	                                        VkPipelineCache pipelineCache,
-	                                        uint32_t createInfoCount,
-	                                        const VkRayTracingPipelineCreateInfoKHR *pCreateInfos,
-	                                        const VkAllocationCallbacks *pAllocator,
-	                                        VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-	}
-
-	VkResult vkGetRayTracingShaderGroupHandlesKHR(
-	    VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
-	}
-
-	VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
-	    VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
-	}
-
-	void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
-	                               const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable,
-	                               const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable,
-	                               const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable,
-	                               const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable,
-	                               VkDeviceAddress indirectDeviceAddress) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdTraceRaysIndirectKHR(
-		    commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
-	}
-
-	VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device,
-	                                                    VkPipeline pipeline,
-	                                                    uint32_t group,
-	                                                    VkShaderGroupShaderKHR groupShader) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
-	}
-
-	void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
-	}
-
-	//=== VK_EXT_vertex_input_dynamic_state ===
-
-	void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer,
-	                            uint32_t vertexBindingDescriptionCount,
-	                            const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions,
-	                            uint32_t vertexAttributeDescriptionCount,
-	                            const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetVertexInputEXT(
-		    commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
-	}
-
-#	if defined(VK_USE_PLATFORM_FUCHSIA)
-	//=== VK_FUCHSIA_external_memory ===
-
-	VkResult vkGetMemoryZirconHandleFUCHSIA(VkDevice device,
-	                                        const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
-	                                        zx_handle_t *pZirconHandle) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
-	}
-
-	VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device,
-	                                                  VkExternalMemoryHandleTypeFlagBits handleType,
-	                                                  zx_handle_t zirconHandle,
-	                                                  VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties);
-	}
-#	endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#	if defined(VK_USE_PLATFORM_FUCHSIA)
-	//=== VK_FUCHSIA_external_semaphore ===
-
-	VkResult vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device,
-	                                              const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
-	}
-
-	VkResult vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device,
-	                                           const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
-	                                           zx_handle_t *pZirconHandle) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
-	}
-#	endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#	if defined(VK_USE_PLATFORM_FUCHSIA)
-	//=== VK_FUCHSIA_buffer_collection ===
-
-	VkResult vkCreateBufferCollectionFUCHSIA(VkDevice device,
-	                                         const VkBufferCollectionCreateInfoFUCHSIA *pCreateInfo,
-	                                         const VkAllocationCallbacks *pAllocator,
-	                                         VkBufferCollectionFUCHSIA *pCollection) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection);
-	}
-
-	VkResult vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device,
-	                                                      VkBufferCollectionFUCHSIA collection,
-	                                                      const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
-	}
-
-	VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device,
-	                                                       VkBufferCollectionFUCHSIA collection,
-	                                                       const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
-	}
-
-	void vkDestroyBufferCollectionFUCHSIA(VkDevice device,
-	                                      VkBufferCollectionFUCHSIA collection,
-	                                      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
-	}
-
-	VkResult vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device,
-	                                                VkBufferCollectionFUCHSIA collection,
-	                                                VkBufferCollectionPropertiesFUCHSIA *pProperties) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
-	}
-#	endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-	//=== VK_HUAWEI_subpass_shading ===
-
-	VkResult
-	vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
-	}
-
-	void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSubpassShadingHUAWEI(commandBuffer);
-	}
-
-	//=== VK_HUAWEI_invocation_mask ===
-
-	void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
-	}
-
-	//=== VK_NV_external_memory_rdma ===
-
-	VkResult vkGetMemoryRemoteAddressNV(VkDevice device,
-	                                    const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo,
-	                                    VkRemoteAddressNV *pAddress) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress);
-	}
-
-	//=== VK_EXT_extended_dynamic_state2 ===
-
-	void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints);
-	}
-
-	void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable);
-	}
-
-	void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable);
-	}
-
-	void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetLogicOpEXT(commandBuffer, logicOp);
-	}
-
-	void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable);
-	}
-
-#	if defined(VK_USE_PLATFORM_SCREEN_QNX)
-	//=== VK_QNX_screen_surface ===
-
-	VkResult vkCreateScreenSurfaceQNX(VkInstance instance,
-	                                  const VkScreenSurfaceCreateInfoQNX *pCreateInfo,
-	                                  const VkAllocationCallbacks *pAllocator,
-	                                  VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface);
-	}
-
-	VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
-	                                                         uint32_t queueFamilyIndex,
-	                                                         struct _screen_window *window) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window);
-	}
-#	endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-	//=== VK_EXT_color_write_enable ===
-
-	void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables);
-	}
-
-	//=== VK_EXT_multi_draw ===
-
-	void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer,
-	                       uint32_t drawCount,
-	                       const VkMultiDrawInfoEXT *pVertexInfo,
-	                       uint32_t instanceCount,
-	                       uint32_t firstInstance,
-	                       uint32_t stride) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
-	}
-
-	void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer,
-	                              uint32_t drawCount,
-	                              const VkMultiDrawIndexedInfoEXT *pIndexInfo,
-	                              uint32_t instanceCount,
-	                              uint32_t firstInstance,
-	                              uint32_t stride,
-	                              const int32_t *pVertexOffset) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
-	}
-
-	//=== VK_EXT_pageable_device_local_memory ===
-
-	void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkSetDeviceMemoryPriorityEXT(device, memory, priority);
-	}
-
-	//=== VK_KHR_maintenance4 ===
-
-	void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device,
-	                                            const VkDeviceBufferMemoryRequirements *pInfo,
-	                                            VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device,
-	                                           const VkDeviceImageMemoryRequirements *pInfo,
-	                                           VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
-	}
-
-	void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device,
-	                                                 const VkDeviceImageMemoryRequirements *pInfo,
-	                                                 uint32_t *pSparseMemoryRequirementCount,
-	                                                 VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-	}
-
-	//=== VK_VALVE_descriptor_set_host_mapping ===
-
-	void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device,
-	                                                  const VkDescriptorSetBindingReferenceVALVE *pBindingReference,
-	                                                  VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping);
-	}
-
-	void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData) const VULKAN_HPP_NOEXCEPT
-	{
-		return ::vkGetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
-	}
-};
+  class DispatchLoaderDynamic;
+#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
+#  if defined( VK_NO_PROTOTYPES )
+#    define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
+#  else
+#    define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
+#  endif
 #endif
 
-class DispatchLoaderDynamic;
-#if !defined(VULKAN_HPP_DISPATCH_LOADER_DYNAMIC)
-#	if defined(VK_NO_PROTOTYPES)
-#		define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
-#	else
-#		define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
-#	endif
+#if !defined( VULKAN_HPP_STORAGE_API )
+#  if defined( VULKAN_HPP_STORAGE_SHARED )
+#    if defined( _MSC_VER )
+#      if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+#        define VULKAN_HPP_STORAGE_API __declspec( dllexport )
+#      else
+#        define VULKAN_HPP_STORAGE_API __declspec( dllimport )
+#      endif
+#    elif defined( __clang__ ) || defined( __GNUC__ )
+#      if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+#        define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
+#      else
+#        define VULKAN_HPP_STORAGE_API
+#      endif
+#    else
+#      define VULKAN_HPP_STORAGE_API
+#      pragma warning Unknown import / export semantics
+#    endif
+#  else
+#    define VULKAN_HPP_STORAGE_API
+#  endif
 #endif
 
-#if !defined(VULKAN_HPP_STORAGE_API)
-#	if defined(VULKAN_HPP_STORAGE_SHARED)
-#		if defined(_MSC_VER)
-#			if defined(VULKAN_HPP_STORAGE_SHARED_EXPORT)
-#				define VULKAN_HPP_STORAGE_API __declspec(dllexport)
-#			else
-#				define VULKAN_HPP_STORAGE_API __declspec(dllimport)
-#			endif
-#		elif defined(__clang__) || defined(__GNUC__)
-#			if defined(VULKAN_HPP_STORAGE_SHARED_EXPORT)
-#				define VULKAN_HPP_STORAGE_API __attribute__((visibility("default")))
-#			else
-#				define VULKAN_HPP_STORAGE_API
-#			endif
-#		else
-#			define VULKAN_HPP_STORAGE_API
-#			pragma warning Unknown import / export semantics
-#		endif
-#	else
-#		define VULKAN_HPP_STORAGE_API
-#	endif
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
+#  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
+#    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE                     \
+      namespace VULKAN_HPP_NAMESPACE                                               \
+      {                                                                            \
+        VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+      }
+  extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
+#  else
+  static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
+  {
+    static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
+    return dls;
+  }
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
+#    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+#  endif
 #endif
 
-#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER)
-#	if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-#		define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
-#		define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE                     \
-			namespace VULKAN_HPP_NAMESPACE {                                           \
-			VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
-			}
-extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
-#	else
-static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic &getDispatchLoaderStatic()
-{
-	static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
-	return dls;
-}
-#		define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
-#		define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
-#	endif
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
+#  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
+#  else
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
+#  endif
 #endif
 
-#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER_TYPE)
-#	if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-#		define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
-#	else
-#		define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
-#	endif
-#endif
-
-#if defined(VULKAN_HPP_NO_DEFAULT_DISPATCHER)
-#	define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
-#	define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
-#	define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
+#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
+#  define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
+#  define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
+#  define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
 #else
-#	define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
-#	define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
-#	define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
+#  define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT         = {}
+#  define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
+#  define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT       = VULKAN_HPP_DEFAULT_DISPATCHER
 #endif
 
-struct AllocationCallbacks;
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+  struct AllocationCallbacks;
 
-template<typename OwnerType, typename Dispatch>
-class ObjectDestroy
-{
-public:
-	ObjectDestroy() = default;
+  template <typename OwnerType, typename Dispatch>
+  class ObjectDestroy
+  {
+  public:
+    ObjectDestroy() = default;
 
-	ObjectDestroy(OwnerType owner,
-	              Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-	              Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
-	    : m_owner(owner),
-	      m_allocationCallbacks(allocationCallbacks),
-	      m_dispatch(&dispatch)
-	{
-	}
+    ObjectDestroy( OwnerType                                               owner,
+                   Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                   Dispatch const & dispatch                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+      : m_owner( owner )
+      , m_allocationCallbacks( allocationCallbacks )
+      , m_dispatch( &dispatch )
+    {
+    }
 
-	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_owner;
-	}
-	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_allocationCallbacks;
-	}
+    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_owner;
+    }
+    Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_allocationCallbacks;
+    }
 
-protected:
-	template<typename T>
-	void destroy(T t) VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_owner && m_dispatch);
-		m_owner.destroy(t, m_allocationCallbacks, *m_dispatch);
-	}
+  protected:
+    template <typename T>
+    void destroy( T t ) VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+      m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
+    }
 
-private:
-	OwnerType m_owner = {};
-	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
-	Dispatch const *m_dispatch = nullptr;
-};
+  private:
+    OwnerType                           m_owner               = {};
+    Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+    Dispatch const *                    m_dispatch            = nullptr;
+  };
 
-class NoParent;
+  class NoParent;
 
-template<typename Dispatch>
-class ObjectDestroy<NoParent, Dispatch>
-{
-public:
-	ObjectDestroy() = default;
+  template <typename Dispatch>
+  class ObjectDestroy<NoParent, Dispatch>
+  {
+  public:
+    ObjectDestroy() = default;
 
-	ObjectDestroy(Optional<const AllocationCallbacks> allocationCallbacks,
-	              Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
-	    : m_allocationCallbacks(allocationCallbacks),
-	      m_dispatch(&dispatch)
-	{
-	}
+    ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
+                   Dispatch const & dispatch           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+      : m_allocationCallbacks( allocationCallbacks )
+      , m_dispatch( &dispatch )
+    {
+    }
 
-	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_allocationCallbacks;
-	}
+    Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_allocationCallbacks;
+    }
 
-protected:
-	template<typename T>
-	void destroy(T t) VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_dispatch);
-		t.destroy(m_allocationCallbacks, *m_dispatch);
-	}
+  protected:
+    template <typename T>
+    void destroy( T t ) VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_dispatch );
+      t.destroy( m_allocationCallbacks, *m_dispatch );
+    }
 
-private:
-	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
-	Dispatch const *m_dispatch = nullptr;
-};
+  private:
+    Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+    Dispatch const *                    m_dispatch            = nullptr;
+  };
 
-template<typename OwnerType, typename Dispatch>
-class ObjectFree
-{
-public:
-	ObjectFree() = default;
+  template <typename OwnerType, typename Dispatch>
+  class ObjectFree
+  {
+  public:
+    ObjectFree() = default;
 
-	ObjectFree(OwnerType owner,
-	           Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-	           Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
-	    : m_owner(owner),
-	      m_allocationCallbacks(allocationCallbacks),
-	      m_dispatch(&dispatch)
-	{
-	}
+    ObjectFree( OwnerType                                               owner,
+                Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                Dispatch const & dispatch                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+      : m_owner( owner )
+      , m_allocationCallbacks( allocationCallbacks )
+      , m_dispatch( &dispatch )
+    {
+    }
 
-	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_owner;
-	}
+    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_owner;
+    }
 
-	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_allocationCallbacks;
-	}
+    Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_allocationCallbacks;
+    }
 
-protected:
-	template<typename T>
-	void destroy(T t) VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_owner && m_dispatch);
-		(m_owner.free)(t, m_allocationCallbacks, *m_dispatch);
-	}
+  protected:
+    template <typename T>
+    void destroy( T t ) VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+      ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
+    }
 
-private:
-	OwnerType m_owner = {};
-	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
-	Dispatch const *m_dispatch = nullptr;
-};
+  private:
+    OwnerType                           m_owner               = {};
+    Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+    Dispatch const *                    m_dispatch            = nullptr;
+  };
 
-template<typename OwnerType, typename Dispatch>
-class ObjectRelease
-{
-public:
-	ObjectRelease() = default;
+  template <typename OwnerType, typename Dispatch>
+  class ObjectRelease
+  {
+  public:
+    ObjectRelease() = default;
 
-	ObjectRelease(OwnerType owner, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
-	    : m_owner(owner),
-	      m_dispatch(&dispatch)
-	{
-	}
+    ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+      : m_owner( owner )
+      , m_dispatch( &dispatch )
+    {
+    }
 
-	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_owner;
-	}
+    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_owner;
+    }
 
-protected:
-	template<typename T>
-	void destroy(T t) VULKAN_HPP_NOEXCEPT
-	{
-		VULKAN_HPP_ASSERT(m_owner && m_dispatch);
-		m_owner.release(t, *m_dispatch);
-	}
+  protected:
+    template <typename T>
+    void destroy( T t ) VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+      m_owner.release( t, *m_dispatch );
+    }
 
-private:
-	OwnerType m_owner = {};
-	Dispatch const *m_dispatch = nullptr;
-};
+  private:
+    OwnerType        m_owner    = {};
+    Dispatch const * m_dispatch = nullptr;
+  };
 
-template<typename OwnerType, typename PoolType, typename Dispatch>
-class PoolFree
-{
-public:
-	PoolFree() = default;
+  template <typename OwnerType, typename PoolType, typename Dispatch>
+  class PoolFree
+  {
+  public:
+    PoolFree() = default;
 
-	PoolFree(OwnerType owner, PoolType pool, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
-	    : m_owner(owner),
-	      m_pool(pool),
-	      m_dispatch(&dispatch)
-	{
-	}
+    PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+      : m_owner( owner )
+      , m_pool( pool )
+      , m_dispatch( &dispatch )
+    {
+    }
 
-	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_owner;
-	}
-	PoolType getPool() const VULKAN_HPP_NOEXCEPT
-	{
-		return m_pool;
-	}
+    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_owner;
+    }
+    PoolType getPool() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_pool;
+    }
 
-protected:
-	template<typename T>
-	void destroy(T t) VULKAN_HPP_NOEXCEPT
-	{
-		(m_owner.free)(m_pool, t, *m_dispatch);
-	}
+  protected:
+    template <typename T>
+    void destroy( T t ) VULKAN_HPP_NOEXCEPT
+    {
+      ( m_owner.free )( m_pool, t, *m_dispatch );
+    }
 
-private:
-	OwnerType m_owner = OwnerType();
-	PoolType m_pool = PoolType();
-	Dispatch const *m_dispatch = nullptr;
-};
+  private:
+    OwnerType        m_owner    = OwnerType();
+    PoolType         m_pool     = PoolType();
+    Dispatch const * m_dispatch = nullptr;
+  };
 
-//==================
-//=== BASE TYPEs ===
-//==================
+#endif  // !VULKAN_HPP_NO_SMART_HANDLE
 
-using Bool32 = uint32_t;
-using DeviceAddress = uint64_t;
-using DeviceSize = uint64_t;
-using RemoteAddressNV = void *;
-using SampleMask = uint32_t;
+  //==================
+  //=== BASE TYPEs ===
+  //==================
+
+  using Bool32          = uint32_t;
+  using DeviceAddress   = uint64_t;
+  using DeviceSize      = uint64_t;
+  using RemoteAddressNV = void *;
+  using SampleMask      = uint32_t;
 
 }  // namespace VULKAN_HPP_NAMESPACE
 
 #include <vulkan/vulkan_enums.hpp>
+#if !defined( VULKAN_HPP_NO_TO_STRING )
+#  include <vulkan/vulkan_to_string.hpp>
+#endif
 
 #ifndef VULKAN_HPP_NO_EXCEPTIONS
-namespace std {
-template<>
-struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
+namespace std
 {
-};
+  template <>
+  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
+  {
+  };
 }  // namespace std
 #endif
 
-namespace VULKAN_HPP_NAMESPACE {
+namespace VULKAN_HPP_NAMESPACE
+{
 #ifndef VULKAN_HPP_NO_EXCEPTIONS
+  class ErrorCategoryImpl : public std::error_category
+  {
+  public:
+    virtual const char * name() const VULKAN_HPP_NOEXCEPT override
+    {
+      return VULKAN_HPP_NAMESPACE_STRING "::Result";
+    }
+    virtual std::string message( int ev ) const override
+    {
+#  if defined( VULKAN_HPP_NO_TO_STRING )
+      return std::to_string( ev );
+#  else
+      return VULKAN_HPP_NAMESPACE::to_string( static_cast<VULKAN_HPP_NAMESPACE::Result>( ev ) );
+#  endif
+    }
+  };
 
-class ErrorCategoryImpl : public std::error_category
-{
-public:
-	virtual const char *name() const VULKAN_HPP_NOEXCEPT override
-	{
-		return VULKAN_HPP_NAMESPACE_STRING "::Result";
-	}
-	virtual std::string message(int ev) const override
-	{
-		return to_string(static_cast<Result>(ev));
-	}
-};
+  class Error
+  {
+  public:
+    Error() VULKAN_HPP_NOEXCEPT                = default;
+    Error( const Error & ) VULKAN_HPP_NOEXCEPT = default;
+    virtual ~Error() VULKAN_HPP_NOEXCEPT       = default;
 
-class Error
-{
-public:
-	Error() VULKAN_HPP_NOEXCEPT = default;
-	Error(const Error &) VULKAN_HPP_NOEXCEPT = default;
-	virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
+    virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0;
+  };
 
-	virtual const char *what() const VULKAN_HPP_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 ) {}
 
-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 const char * what() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::logic_error::what();
+    }
+  };
 
-	virtual const char *what() const VULKAN_HPP_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 ) {}
 
-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 const char * what() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::system_error::what();
+    }
+  };
 
-	virtual const char *what() const VULKAN_HPP_NOEXCEPT
-	{
-		return std::system_error::what();
-	}
-};
+  VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT
+  {
+    static ErrorCategoryImpl instance;
+    return instance;
+  }
 
-VULKAN_HPP_INLINE const std::error_category &errorCategory() VULKAN_HPP_NOEXCEPT
-{
-	static ErrorCategoryImpl instance;
-	return instance;
-}
+  VULKAN_HPP_INLINE std::error_code make_error_code( Result e ) VULKAN_HPP_NOEXCEPT
+  {
+    return std::error_code( static_cast<int>( e ), errorCategory() );
+  }
 
-VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_NOEXCEPT
-{
-	return std::error_code(static_cast<int>(e), errorCategory());
-}
+  VULKAN_HPP_INLINE std::error_condition make_error_condition( Result e ) VULKAN_HPP_NOEXCEPT
+  {
+    return std::error_condition( static_cast<int>( e ), errorCategory() );
+  }
 
-VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_NOEXCEPT
-{
-	return std::error_condition(static_cast<int>(e), errorCategory());
-}
+  class OutOfHostMemoryError : public SystemError
+  {
+  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 OutOfHostMemoryError : public SystemError
-{
-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 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 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 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 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 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 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 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 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 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 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 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 UnknownError : public SystemError
+  {
+  public:
+    UnknownError( std::string const & message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
+    UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
+  };
 
-class UnknownError : public SystemError
-{
-public:
-	UnknownError(std::string const &message)
-	    : SystemError(make_error_code(Result::eErrorUnknown), message)
-	{}
-	UnknownError(char const *message)
-	    : SystemError(make_error_code(Result::eErrorUnknown), 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 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 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 FragmentationError : public SystemError
+  {
+  public:
+    FragmentationError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
+    FragmentationError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
+  };
 
-class FragmentationError : public SystemError
-{
-public:
-	FragmentationError(std::string const &message)
-	    : SystemError(make_error_code(Result::eErrorFragmentation), message)
-	{}
-	FragmentationError(char const *message)
-	    : SystemError(make_error_code(Result::eErrorFragmentation), message)
-	{}
-};
+  class InvalidOpaqueCaptureAddressError : public SystemError
+  {
+  public:
+    InvalidOpaqueCaptureAddressError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
+    InvalidOpaqueCaptureAddressError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
+  };
 
-class InvalidOpaqueCaptureAddressError : public SystemError
-{
-public:
-	InvalidOpaqueCaptureAddressError(std::string const &message)
-	    : SystemError(make_error_code(Result::eErrorInvalidOpaqueCaptureAddress), message)
-	{}
-	InvalidOpaqueCaptureAddressError(char const *message)
-	    : SystemError(make_error_code(Result::eErrorInvalidOpaqueCaptureAddress), 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 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 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 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 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 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 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)
-	{}
-};
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+  class ImageUsageNotSupportedKHRError : public SystemError
+  {
+  public:
+    ImageUsageNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
+    ImageUsageNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
+  };
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-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)
-	{
-	}
-};
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+  class VideoPictureLayoutNotSupportedKHRError : public SystemError
+  {
+  public:
+    VideoPictureLayoutNotSupportedKHRError( std::string const & message )
+      : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
+    {
+    }
+    VideoPictureLayoutNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
+    {
+    }
+  };
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-class NotPermittedKHRError : public SystemError
-{
-public:
-	NotPermittedKHRError(std::string const &message)
-	    : SystemError(make_error_code(Result::eErrorNotPermittedKHR), message)
-	{}
-	NotPermittedKHRError(char const *message)
-	    : SystemError(make_error_code(Result::eErrorNotPermittedKHR), message)
-	{}
-};
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+  class VideoProfileOperationNotSupportedKHRError : public SystemError
+  {
+  public:
+    VideoProfileOperationNotSupportedKHRError( std::string const & message )
+      : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
+    {
+    }
+    VideoProfileOperationNotSupportedKHRError( char const * message )
+      : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
+    {
+    }
+  };
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-class FullScreenExclusiveModeLostEXTError : public SystemError
-{
-public:
-	FullScreenExclusiveModeLostEXTError(std::string const &message)
-	    : SystemError(make_error_code(Result::eErrorFullScreenExclusiveModeLostEXT), message)
-	{
-	}
-	FullScreenExclusiveModeLostEXTError(char const *message)
-	    : SystemError(make_error_code(Result::eErrorFullScreenExclusiveModeLostEXT), message)
-	{}
-};
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+  class VideoProfileFormatNotSupportedKHRError : public SystemError
+  {
+  public:
+    VideoProfileFormatNotSupportedKHRError( std::string const & message )
+      : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
+    {
+    }
+    VideoProfileFormatNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
+    {
+    }
+  };
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-namespace {
-[[noreturn]] 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::eErrorUnknown: throw UnknownError(message);
-	case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError(message);
-	case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError(message);
-	case Result::eErrorFragmentation: throw FragmentationError(message);
-	case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError(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::eErrorNotPermittedKHR: throw NotPermittedKHRError(message);
-#	if defined(VK_USE_PLATFORM_WIN32_KHR)
-	case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError(message);
-#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
-	default: throw SystemError(make_error_code(result));
-	}
-}
-}  // namespace
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+  class VideoProfileCodecNotSupportedKHRError : public SystemError
+  {
+  public:
+    VideoProfileCodecNotSupportedKHRError( std::string const & message )
+      : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message )
+    {
+    }
+    VideoProfileCodecNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {}
+  };
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+  class VideoStdVersionNotSupportedKHRError : public SystemError
+  {
+  public:
+    VideoStdVersionNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message )
+    {
+    }
+    VideoStdVersionNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {}
+  };
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+  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 NotPermittedKHRError : public SystemError
+  {
+  public:
+    NotPermittedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
+    NotPermittedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
+  };
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+  class FullScreenExclusiveModeLostEXTError : public SystemError
+  {
+  public:
+    FullScreenExclusiveModeLostEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message )
+    {
+    }
+    FullScreenExclusiveModeLostEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
+  };
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  class CompressionExhaustedEXTError : public SystemError
+  {
+  public:
+    CompressionExhaustedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
+    CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
+  };
+
+  namespace
+  {
+    [[noreturn]] 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::eErrorUnknown: throw UnknownError( message );
+        case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
+        case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
+        case Result::eErrorFragmentation: throw FragmentationError( message );
+        case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( 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 );
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+        case Result::eErrorImageUsageNotSupportedKHR: throw ImageUsageNotSupportedKHRError( message );
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+        case Result::eErrorVideoPictureLayoutNotSupportedKHR: throw VideoPictureLayoutNotSupportedKHRError( message );
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+        case Result::eErrorVideoProfileOperationNotSupportedKHR: throw VideoProfileOperationNotSupportedKHRError( message );
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+        case Result::eErrorVideoProfileFormatNotSupportedKHR: throw VideoProfileFormatNotSupportedKHRError( message );
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+        case Result::eErrorVideoProfileCodecNotSupportedKHR: throw VideoProfileCodecNotSupportedKHRError( message );
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+        case Result::eErrorVideoStdVersionNotSupportedKHR: throw VideoStdVersionNotSupportedKHRError( message );
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+        case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
+        case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError( message );
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+        case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+        case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
+        default: throw SystemError( make_error_code( result ) );
+      }
+    }
+  }  // namespace
 #endif
 
-template<typename T>
-void ignore(T const &) VULKAN_HPP_NOEXCEPT
-{
-}
+  template <typename T>
+  void ignore( T const & ) VULKAN_HPP_NOEXCEPT
+  {
+  }
 
-template<typename T>
-struct ResultValue
-{
+  template <typename T>
+  struct ResultValue
+  {
 #ifdef VULKAN_HPP_HAS_NOEXCEPT
-	ResultValue(Result r, T &v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(v)))
+    ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( v ) ) )
 #else
-	ResultValue(Result r, T &v)
+    ResultValue( Result r, T & v )
 #endif
-	    : result(r)
-	    , value(v)
-	{
-	}
+      : result( r ), value( v )
+    {
+    }
 
 #ifdef VULKAN_HPP_HAS_NOEXCEPT
-	ResultValue(Result r, T &&v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(std::move(v))))
+    ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) )
 #else
-	ResultValue(Result r, T &&v)
+    ResultValue( Result r, T && v )
 #endif
-	    : result(r)
-	    , value(std::move(v))
-	{
-	}
+      : result( r ), value( std::move( v ) )
+    {
+    }
 
-	Result result;
-	T value;
+    Result result;
+    T      value;
 
-	operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
-	{
-		return std::tuple<Result &, T &>(result, value);
-	}
+    operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
+    {
+      return std::tuple<Result &, T &>( result, value );
+    }
+  };
 
-#if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
-	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
-	operator T const &() const &VULKAN_HPP_NOEXCEPT
-	{
-		return value;
-	}
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+  template <typename Type, typename Dispatch>
+  struct ResultValue<UniqueHandle<Type, Dispatch>>
+  {
+#  ifdef VULKAN_HPP_HAS_NOEXCEPT
+    ResultValue( Result r, UniqueHandle<Type, Dispatch> && v ) VULKAN_HPP_NOEXCEPT
+#  else
+    ResultValue( Result r, UniqueHandle<Type, Dispatch> && v )
+#  endif
+      : result( r )
+      , value( std::move( v ) )
+    {
+    }
 
-	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
-	operator T &() & VULKAN_HPP_NOEXCEPT
-	{
-		return value;
-	}
+    std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
+    {
+      return std::make_tuple( result, std::move( value ) );
+    }
 
-	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
-	operator T const &&() const &&VULKAN_HPP_NOEXCEPT
-	{
-		return std::move(value);
-	}
+    Result                       result;
+    UniqueHandle<Type, Dispatch> value;
+  };
 
-	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
-	operator T &&() && VULKAN_HPP_NOEXCEPT
-	{
-		return std::move(value);
-	}
-#endif
-};
+  template <typename Type, typename Dispatch>
+  struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
+  {
+#  ifdef VULKAN_HPP_HAS_NOEXCEPT
+    ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
+#  else
+    ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
+#  endif
+      : result( r )
+      , value( std::move( v ) )
+    {
+    }
 
-#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
-template<typename Type, typename Dispatch>
-struct ResultValue<UniqueHandle<Type, Dispatch>>
-{
-#	ifdef VULKAN_HPP_HAS_NOEXCEPT
-	ResultValue(Result r, UniqueHandle<Type, Dispatch> &&v) VULKAN_HPP_NOEXCEPT
-#	else
-	ResultValue(Result r, UniqueHandle<Type, Dispatch> &&v)
-#	endif
-	    : result(r),
-	      value(std::move(v))
-	{
-	}
+    std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
+    {
+      return std::make_tuple( result, std::move( value ) );
+    }
 
-	std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
-	{
-		return std::make_tuple(result, std::move(value));
-	}
-
-#	if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
-	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
-	operator UniqueHandle<Type, Dispatch> &() & VULKAN_HPP_NOEXCEPT
-	{
-		return value;
-	}
-
-	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
-	operator UniqueHandle<Type, Dispatch>() VULKAN_HPP_NOEXCEPT
-	{
-		return std::move(value);
-	}
-#	endif
-
-	Result result;
-	UniqueHandle<Type, Dispatch> value;
-};
-
-template<typename Type, typename Dispatch>
-struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
-{
-#	ifdef VULKAN_HPP_HAS_NOEXCEPT
-	ResultValue(Result r, std::vector<UniqueHandle<Type, Dispatch>> &&v) VULKAN_HPP_NOEXCEPT
-#	else
-	ResultValue(Result r, std::vector<UniqueHandle<Type, Dispatch>> &&v)
-#	endif
-	    : result(r),
-	      value(std::move(v))
-	{
-	}
-
-	std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
-	{
-		return std::make_tuple(result, std::move(value));
-	}
-
-	Result result;
-	std::vector<UniqueHandle<Type, Dispatch>> value;
-
-#	if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
-	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
-	operator std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>() VULKAN_HPP_NOEXCEPT
-	{
-		return std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>(result, value);
-	}
-#	endif
-};
+    Result                                    result;
+    std::vector<UniqueHandle<Type, Dispatch>> value;
+  };
 #endif
 
-template<typename T>
-struct ResultValueType
-{
+  template <typename T>
+  struct ResultValueType
+  {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-	typedef ResultValue<T> type;
+    typedef ResultValue<T> type;
 #else
-	typedef T type;
+    typedef T    type;
 #endif
-};
+  };
 
-template<>
-struct ResultValueType<void>
-{
+  template <>
+  struct ResultValueType<void>
+  {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-	typedef Result type;
+    typedef Result type;
 #else
-	typedef void type;
+    typedef void type;
 #endif
-};
+  };
 
-template<typename T>
-VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue(Result result, T &data, char const *message)
-{
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
+  {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-	ignore(message);
-	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
-	return ResultValue<T>(result, std::move(data));
+    return result;
 #else
-	if(result != Result::eSuccess)
-	{
-		throwResultException(result, message);
-	}
-	return std::move(data);
+    ignore( result );
 #endif
-}
+  }
 
-template<typename T>
-VULKAN_HPP_INLINE ResultValue<T> createResultValue(Result result, T &data, char const *message, std::initializer_list<Result> successCodes)
-{
+  template <typename T>
+  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T & data )
+  {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-	ignore(message);
-	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
+    return ResultValue<T>( result, data );
 #else
-	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
-	{
-		throwResultException(result, message);
-	}
+    ignore( result );
+    return data;
 #endif
-	return ResultValue<T>(result, std::move(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
-	ignore(message);
-	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
-	return ResultValue<UniqueHandle<T, D>>(result, UniqueHandle<T, D>(data, deleter));
-#	else
-	if(result != Result::eSuccess)
-	{
-		throwResultException(result, message);
-	}
-	return UniqueHandle<T, D>(data, deleter);
-#	endif
-}
-
-template<typename T, typename D>
-VULKAN_HPP_INLINE ResultValue<UniqueHandle<T, D>> createResultValue(
-    Result result, T &data, char const *message, std::initializer_list<Result> successCodes, typename UniqueHandleTraits<T, D>::deleter const &deleter)
-{
-#	ifdef VULKAN_HPP_NO_EXCEPTIONS
-	ignore(message);
-	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
-#	else
-	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
-	{
-		throwResultException(result, message);
-	}
-#	endif
-	return ResultValue<UniqueHandle<T, D>>(result, UniqueHandle<T, D>(data, deleter));
-}
-
-template<typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
-VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>, Allocator>>::type
-createResultValue(Result result, std::vector<UniqueHandle<T, D>, Allocator> &&data, char const *message)
-{
-#	ifdef VULKAN_HPP_NO_EXCEPTIONS
-	ignore(message);
-	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
-	return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>(result, std::move(data));
-#	else
-	if(result != Result::eSuccess)
-	{
-		throwResultException(result, message);
-	}
-	return std::move(data);
-#	endif
-}
-
-template<typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
-VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>
-createResultValue(Result result, std::vector<UniqueHandle<T, D>, Allocator> &&data, char const *message, std::initializer_list<Result> successCodes)
-{
-#	ifdef VULKAN_HPP_NO_EXCEPTIONS
-	ignore(message);
-	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
-#	else
-	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
-	{
-		throwResultException(result, message);
-	}
-#	endif
-	return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>(result, std::move(data));
-}
-#endif
-
-template<typename T>
-VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType(Result result, T &data)
-{
+  template <typename T>
+  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T && data )
+  {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-	return ResultValue<T>(result, std::move(data));
+    return ResultValue<T>( result, std::move( data ) );
 #else
-	ignore(result);
-	return std::move(data);
+    ignore( result );
+    return std::move( data );
 #endif
-}
+  }
 
-VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType(Result result)
-{
+  VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
+  {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-	return result;
+    ignore( result );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+    ignore( message );
+    VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
 #else
-	ignore(result);
+    if ( result != Result::eSuccess )
+    {
+      throwResultException( result, message );
+    }
 #endif
-}
+  }
 
-VULKAN_HPP_INLINE void resultCheck(Result result, char const *message)
-{
+  VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
+  {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-	ignore(result);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-	ignore(message);
-	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
+    ignore( result );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+    ignore( message );
+    ignore( successCodes );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+    VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
 #else
-	if(result != Result::eSuccess)
-	{
-		throwResultException(result, message);
-	}
+    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    {
+      throwResultException( result, message );
+    }
 #endif
-}
-
-VULKAN_HPP_INLINE void resultCheck(Result result, char const *message, std::initializer_list<Result> successCodes)
-{
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-	ignore(result);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-	ignore(message);
-	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
-#else
-	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
-	{
-		throwResultException(result, message);
-	}
-#endif
-}
+  }
 }  // namespace VULKAN_HPP_NAMESPACE
 
 // clang-format off
@@ -6248,7695 +6193,8212 @@
 #include <vulkan/vulkan_funcs.hpp>
 // clang-format on
 
-namespace VULKAN_HPP_NAMESPACE {
-//=======================
-//=== STRUCTS EXTENDS ===
-//=======================
-
-//=== VK_VERSION_1_0 ===
-template<>
-struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>
+namespace VULKAN_HPP_NAMESPACE
 {
-	enum
-	{
-		value = true
-	};
-};
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
 
-//=== VK_VERSION_1_1 ===
-template<>
-struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ProtectedSubmitInfo, SubmitInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
+  //=======================
+  //=== STRUCTS EXTENDS ===
+  //=======================
 
-//=== VK_VERSION_1_2 ===
-template<>
-struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
+  //=== VK_VERSION_1_0 ===
+  template <>
+  struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
 
-//=== VK_VERSION_1_3 ===
-template<>
-struct StructExtends<PhysicalDeviceVulkan13Features, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan13Features, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan13Properties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, GraphicsPipelineCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, ComputePipelineCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoNV>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoKHR>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevicePrivateDataFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevicePrivateDataFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DevicePrivateDataCreateInfo, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<MemoryBarrier2, SubpassDependency2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSynchronization2Features, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSynchronization2Features, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceImageRobustnessFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceImageRobustnessFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceSubgroupSizeControlProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, PipelineShaderStageCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceInlineUniformBlockProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<WriteDescriptorSetInlineUniformBlock, WriteDescriptorSet>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfo, DescriptorPoolCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PipelineRenderingCreateInfo, GraphicsPipelineCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<CommandBufferInheritanceRenderingInfo, CommandBufferInheritanceInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderIntegerDotProductProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceTexelBufferAlignmentProperties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<FormatProperties3, FormatProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance4Features, PhysicalDeviceFeatures2>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance4Features, DeviceCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance4Properties, PhysicalDeviceProperties2>
-{
-	enum
-	{
-		value = true
-	};
-};
+  //=== VK_VERSION_1_1 ===
+  template <>
+  struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ProtectedSubmitInfo, SubmitInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
 
-//=== VK_KHR_swapchain ===
-template<>
-struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR>
-{
-	enum
-	{
-		value = true
-	};
-};
-template<>
-struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR>
-{
-	enum
-	{
-		value = true
-	};
-};
+  //=== VK_VERSION_1_2 ===
+  template <>
+  struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct St