diff --git a/.github/workflows/Windows-LLVM.yml b/.github/workflows/Windows-LLVM.yml
index 5ccf7297..ade85607 100644
--- a/.github/workflows/Windows-LLVM.yml
+++ b/.github/workflows/Windows-LLVM.yml
@@ -51,7 +51,7 @@ jobs:
         id: cache_llvm
         uses: actions/cache@v3.2.2
         with:
-          path: ${{ runner.workspace }}/StormKit/llvm2/
+          path: ${{ runner.workspace }}/StormKit/llvm/
           key: ${{ matrix.os }}-llvm
           restore-keys: |
             ${{ matrix.os }}-llvm
@@ -59,9 +59,9 @@ jobs:
       - name: Download and Uncompress LLVM
         if: ${{ steps.cache_llvm.outputs.cache-hit != 'true' }}
         run: |
-          C:/msys64/usr/bin/wget 'http://86.221.35.29:1337/llvm-win.7z'
-          7z x llvm-win.7z
-          rm llvm-win.7z
+          C:/msys64/usr/bin/wget 'https://github.com/Arthapz/llvm-patched/raw/main/windows/llvm-x64.7z'
+          7z x llvm-x64.7z
+          rm llvm-x64.7z
 
       - name: Set xmake env
         run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" >> $env:GITHUB_ENV
@@ -69,12 +69,15 @@ jobs:
       - name: Install xmake
         uses: xmake-io/github-action-setup-xmake@v1
         with:
-          xmake-version: branch@dev
+          xmake-version: "branch@dev"
           actions-cache-folder: .xmake-cache-${{ steps.cache_key.outputs.key }}
 
-      - name: Update xmake repository
-        run: xmake repo --update
+      - name: Update xmake to patched xmake
+        run: xmake update -s https://github.com/Arthapz/xmake.git#modules
 
+      # - name: Update xmake repository
+      #   run: xmake repo --update
+      #
       - name: Retrieve dependencies hash
         id: dep_hash
         run: echo "hash=$(xmake l utils.ci.packageskey)" >> $env:GITHUB_OUTPUT
@@ -88,18 +91,18 @@ jobs:
       - name: Configure & Build
         id: build_llvm
         run: |
-          xmake f -vD --yes -a ${{ matrix.arch }}  -m ${{ (matrix.mode == 'release' || matrix.mode == 'debug') && matrix.mode || 'releasedbg' }} -k ${{ matrix.kind }} --enable_examples=y --enable_tests=y --enable_gpu=n --libc++=y --toolchain=llvm --sdk="${{ runner.workspace }}/StormKit/llvm2/" --libc++=y --cxxflags="-stdlib=libc++ -fno-delayed-template-parsing -cxx-isystem${{ runner.workspace }}/StormKit/llvm2/include/c++/v1" --ldflags="-stdlib=libc++ -L${{ runner.workspace }}/StormKit/llvm2/lib" --shflags="-stdlib=libc++ -L${{ runner.workspace }}/StormKit/llvm2/lib"
+          xmake f -vD --yes -a ${{ matrix.arch }}  -m ${{ (matrix.mode == 'release' || matrix.mode == 'debug') && matrix.mode || 'releasedbg' }} -k ${{ matrix.kind }} --enable_examples=y --toolchain=llvm --sdk="${{ runner.workspace }}/StormKit/llvm/" --runtimes="c++_shared"
           xmake b -vD
 
       - name: Tests
         run: |
-          cp "${{ runner.workspace }}/StormKit/llvm2/lib/c++.dll" "${{ runner.workspace }}/StormKit/build/windows/${{ matrix.arch }}/${{ (matrix.mode == 'release' || matrix.mode == 'debug') && matrix.mode || 'releasedbg' }}/"
+          cp "${{ runner.workspace }}/StormKit/llvm/lib/c++.dll" "${{ runner.workspace }}/StormKit/build/windows/${{ matrix.arch }}/${{ (matrix.mode == 'release' || matrix.mode == 'debug') && matrix.mode || 'releasedbg' }}/"
           xmake test -vD
 
       - name: Installation
         run: |
           xmake install -vD --installdir="${{ runner.workspace }}/output"
-          cp "${{ runner.workspace }}/StormKit/llvm2/lib/c++.dll" "${{ runner.workspace }}/output/bin/"
+          cp "${{ runner.workspace }}/StormKit/llvm/lib/c++.dll" "${{ runner.workspace }}/output/bin/"
           rmdir /s /q "StormKit"
 
       - name: Upload artifacts
diff --git a/INSTALL.md b/INSTALL.md
index 090556f2..f3b29d15 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -1,12 +1,16 @@
 # Installation
 
-A C++23 compliant compiler is needed to build StormKit and XMake build system
+A C++23 compliant compiler with std module support and XMake is needed to build StormKit
 
 ## Dependencies
 ### StormKit-core module
 - [glm](https://github.com/g-truc/glm)
+- [frozen](https://github.com/serge-sans-paille/frozen)
+- [unordered_dense](github.com/martinus/unordered_dense)
+- [magic_enum](https://github.com/Neargye/magic_enum)
 
 ### StormKit-image module
+- [gli](https://github.com/g-truc/gli)
 - [LibPNG >= 1.6](http://www.libpng.org/pub/png/libpng.html)
 - [LibJPEG-turbo](https://www.libjpeg-turbo.org)
 
@@ -15,12 +19,9 @@ A C++23 compliant compiler is needed to build StormKit and XMake build system
 - [VulkanMemoryAllocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
 - [VulkanMemoryAllocator-hpp](https://github.com/YaaZ/VulkanMemoryAllocator-Hpp)
 
-### StormKit-engine module
-- [gli](https://github.com/g-truc/gli)
-
 ## Building
 ```
-> xmake f -m <release|debug|releasedbg> -k <shared|static>
+> xmake f -m <release|debug|releasedbg> -k <shared|static> --runtimes=<c++_shared|c++_static|libstdc++_shared|libstdc++_static|MT|MD|MTd|MDd>
 > xmake b
 ```
 
diff --git a/examples/engine/triangle/xmake.lua b/examples/engine/triangle/xmake.lua
index 1100dd42..cbde4e73 100644
--- a/examples/engine/triangle/xmake.lua
+++ b/examples/engine/triangle/xmake.lua
@@ -1,28 +1,28 @@
-add_requires("nzsl", { configs = { fs_watcher = false } })
-
-target("triangle")
-do
-	set_kind("binary")
-	set_languages("cxxlatest", "clatest")
-
-	-- add_rules("@nzsl/compile.shaders")
-	add_rules("compile.shaders")
-	add_deps("stormkit-core", "stormkit-main", "stormkit-log", "stormkit-wsi", "stormkit-engine")
-
-	if is_mode("debug") then
-		add_defines("STORMKIT_BUILD_DEBUG")
-		add_defines("STORMKIT_ASSERT=1")
-		set_suffixname("-d")
-	else
-		add_defines("STORMKIT_ASSERT=0")
-	end
-
-	add_files("src/*.cpp")
-	add_files("src/*.mpp")
-	add_files("shaders/*.nzsl")
-	if is_plat("windows") then
-		add_files("win32/*.manifest")
-	end
-
-	set_group("examples/stormkit-engine")
-end
+-- add_requires("nzsl", { configs = { fs_watcher = false } })
+--
+-- target("triangle")
+-- do
+-- 	set_kind("binary")
+-- 	set_languages("cxxlatest", "clatest")
+--
+-- 	-- add_rules("@nzsl/compile.shaders")
+-- 	add_rules("compile.shaders")
+-- 	add_deps("stormkit-core", "stormkit-main", "stormkit-log", "stormkit-wsi", "stormkit-engine")
+--
+-- 	if is_mode("debug") then
+-- 		add_defines("STORMKIT_BUILD_DEBUG")
+-- 		add_defines("STORMKIT_ASSERT=1")
+-- 		set_suffixname("-d")
+-- 	else
+-- 		add_defines("STORMKIT_ASSERT=0")
+-- 	end
+--
+-- 	add_files("src/*.cpp")
+-- 	add_files("src/*.mpp")
+-- 	add_files("shaders/*.nzsl")
+-- 	if is_plat("windows") then
+-- 		add_files("win32/*.manifest")
+-- 	end
+--
+-- 	set_group("examples/stormkit-engine")
+-- end
diff --git a/examples/log/console-logger/xmake.lua b/examples/log/console-logger/xmake.lua
index 9f8d41ef..5ad0f4eb 100644
--- a/examples/log/console-logger/xmake.lua
+++ b/examples/log/console-logger/xmake.lua
@@ -14,6 +14,10 @@ do
 
 	add_files("src/main.cpp")
 
+  if is_plat("windows") then
+      add_ldflags("-Wl,/SUBSYSTEM:CONSOLE", {force = true})
+  end
+
 	if has_config("mold") then
 		add_ldflags("-Wl,-fuse-ld=mold")
 		add_shflags("-Wl,-fuse-ld=mold")
diff --git a/examples/log/file-logger/xmake.lua b/examples/log/file-logger/xmake.lua
index 00114702..16ecc29b 100644
--- a/examples/log/file-logger/xmake.lua
+++ b/examples/log/file-logger/xmake.lua
@@ -14,6 +14,10 @@ do
 
 	add_files("src/main.cpp")
 
+  if is_plat("windows") then
+      add_ldflags("-Wl,/SUBSYSTEM:CONSOLE", {force = true})
+  end
+
 	if has_config("mold") then
 		add_ldflags("-Wl,-fuse-ld=mold")
 		add_shflags("-Wl,-fuse-ld=mold")
diff --git a/examples/wsi/event_handler/xmake.lua b/examples/wsi/event_handler/xmake.lua
index d71381dc..f48c8ac8 100644
--- a/examples/wsi/event_handler/xmake.lua
+++ b/examples/wsi/event_handler/xmake.lua
@@ -15,6 +15,7 @@ do
 	add_files("src/main.cpp")
 	if is_plat("windows") then
 		add_files("win32/*.manifest")
+    add_ldflags("-Wl,/SUBSYSTEM:CONSOLE", {force = true})
 	end
 
 	if has_config("mold") then
diff --git a/examples/wsi/polling/xmake.lua b/examples/wsi/polling/xmake.lua
index 3c9e57f5..6e14c211 100644
--- a/examples/wsi/polling/xmake.lua
+++ b/examples/wsi/polling/xmake.lua
@@ -15,6 +15,7 @@ do
 	add_files("src/main.cpp")
 	if is_plat("windows") then
 		add_files("win32/*.manifest")
+    add_ldflags("-Wl,/SUBSYSTEM:WINDOWS", {force = true})
 	end
 
 	if has_config("mold") then
diff --git a/include/stormkit/Core/PlatformMacro.hpp b/include/stormkit/Core/PlatformMacro.hpp
index 92c08449..764d4d82 100644
--- a/include/stormkit/Core/PlatformMacro.hpp
+++ b/include/stormkit/Core/PlatformMacro.hpp
@@ -118,11 +118,11 @@ extern "C" {
 
 #ifndef STORMKIT_STATIC
     #ifdef STORMKIT_BUILD
-        #define STORMKIT_PUBLIC STORMKIT_EXPORT
+        #define STORMKIT_API STORMKIT_EXPORT
     #else
-        #define STORMKIT_PUBLIC STORMKIT_IMPORT
+        #define STORMKIT_API STORMKIT_IMPORT
     #endif
-    #define STORMKIT_API STORMKIT_EXPORT
+    // #define STORMKIT_API STORMKIT_EXPORT
 #else
     #define STORMKIT_PUBLIC
     #define STORMKIT_API
diff --git a/modules/stormkit/Core/Utils/Detail/GLM.mpp b/modules/stormkit/Core/Utils/Detail/GLM.mpp
deleted file mode 100644
index d928e12d..00000000
--- a/modules/stormkit/Core/Utils/Detail/GLM.mpp
+++ /dev/null
@@ -1,310 +0,0 @@
-module;
-
-#include <glm/glm.hpp>
-
-#include <glm/gtc/quaternion.hpp>
-#include <glm/integer.hpp>
-
-export module stormkit.Core:Utils.Details.GLM;
-
-export namespace glm {
-    /* glm.hpp */
-    using glm::abs;
-    using glm::ceil;
-    using glm::clamp;
-    using glm::floatBitsToInt;
-    using glm::floatBitsToUint;
-    using glm::floor;
-    using glm::fma;
-    using glm::fract;
-    using glm::frexp;
-    using glm::intBitsToFloat;
-    using glm::isinf;
-    using glm::isnan;
-    using glm::ldexp;
-    using glm::max;
-    using glm::min;
-    using glm::mix;
-    using glm::mod;
-    using glm::modf;
-    using glm::round;
-    using glm::roundEven;
-    using glm::sign;
-    using glm::smoothstep;
-    using glm::step;
-    using glm::trunc;
-    using glm::uintBitsToFloat;
-
-    using glm::exp;
-    using glm::exp2;
-    using glm::inversesqrt;
-    using glm::log;
-    using glm::log2;
-    using glm::pow;
-    using glm::sqrt;
-
-    using glm::cross;
-    using glm::distance;
-    using glm::dot;
-    using glm::faceforward;
-    using glm::length;
-    using glm::normalize;
-    using glm::reflect;
-    using glm::refract;
-
-    using glm::mat;
-
-    using glm::dmat2;
-    using glm::dmat2x2;
-    using glm::highp_dmat2;
-    using glm::highp_dmat2x2;
-    using glm::highp_mat2;
-    using glm::highp_mat2x2;
-    using glm::lowp_dmat2;
-    using glm::lowp_dmat2x2;
-    using glm::lowp_mat2;
-    using glm::lowp_mat2x2;
-    using glm::mat2;
-    using glm::mat2x2;
-    using glm::mediump_dmat2;
-    using glm::mediump_dmat2x2;
-    using glm::mediump_mat2;
-    using glm::mediump_mat2x2;
-
-    using glm::dmat2x3;
-    using glm::highp_dmat2x3;
-    using glm::highp_mat2x3;
-    using glm::lowp_dmat2x3;
-    using glm::lowp_mat2x3;
-    using glm::mat2x3;
-    using glm::mediump_dmat2x3;
-    using glm::mediump_mat2x3;
-
-    using glm::dmat2x4;
-    using glm::highp_dmat2x4;
-    using glm::highp_mat2x4;
-    using glm::lowp_dmat2x4;
-    using glm::lowp_mat2x4;
-    using glm::mat2x4;
-    using glm::mediump_dmat2x4;
-    using glm::mediump_mat2x4;
-
-    using glm::dmat3x2;
-    using glm::highp_dmat3x2;
-    using glm::highp_mat3x2;
-    using glm::lowp_dmat3x2;
-    using glm::lowp_mat3x2;
-    using glm::mat3x2;
-    using glm::mediump_dmat3x2;
-    using glm::mediump_mat3x2;
-
-    using glm::dmat3;
-    using glm::dmat3x3;
-    using glm::highp_dmat3;
-    using glm::highp_dmat3x3;
-    using glm::highp_mat3;
-    using glm::highp_mat3x3;
-    using glm::lowp_dmat3;
-    using glm::lowp_dmat3x3;
-    using glm::lowp_mat3;
-    using glm::lowp_mat3x3;
-    using glm::mat3;
-    using glm::mat3x3;
-    using glm::mediump_dmat3;
-    using glm::mediump_dmat3x3;
-    using glm::mediump_mat3;
-    using glm::mediump_mat3x3;
-
-    using glm::dmat3x4;
-    using glm::highp_dmat3x4;
-    using glm::highp_mat3x4;
-    using glm::lowp_dmat3x4;
-    using glm::lowp_mat3x4;
-    using glm::mat3x4;
-    using glm::mediump_dmat3x4;
-    using glm::mediump_mat3x4;
-
-    using glm::dmat4x2;
-    using glm::highp_dmat4x2;
-    using glm::highp_mat4x2;
-    using glm::lowp_dmat4x2;
-    using glm::lowp_mat4x2;
-    using glm::mat4x2;
-    using glm::mediump_dmat4x2;
-    using glm::mediump_mat4x2;
-
-    using glm::dmat4x3;
-    using glm::highp_dmat4x3;
-    using glm::highp_mat4x3;
-    using glm::lowp_dmat4x3;
-    using glm::lowp_mat4x3;
-    using glm::mat4x3;
-    using glm::mediump_dmat4x3;
-    using glm::mediump_mat4x3;
-
-    using glm::dmat4;
-    using glm::dmat4x4;
-    using glm::highp_dmat4;
-    using glm::highp_dmat4x4;
-    using glm::highp_mat4;
-    using glm::highp_mat4x4;
-    using glm::lowp_dmat4;
-    using glm::lowp_dmat4x4;
-    using glm::lowp_mat4;
-    using glm::lowp_mat4x4;
-    using glm::mat4;
-    using glm::mat4x4;
-    using glm::mediump_dmat4;
-    using glm::mediump_dmat4x4;
-    using glm::mediump_mat4;
-    using glm::mediump_mat4x4;
-
-    using glm::packDouble2x32;
-    using glm::packHalf2x16;
-    using glm::packSnorm4x8;
-    using glm::packUnorm2x16;
-    using glm::packUnorm4x8;
-    using glm::unpackDouble2x32;
-    using glm::unpackHalf2x16;
-    using glm::unpackSnorm2x16;
-    using glm::unpackSnorm4x8;
-    using glm::unpackUnorm2x16;
-    using glm::unpackUnorm4x8;
-
-    using glm::acos;
-    using glm::acosh;
-    using glm::asin;
-    using glm::asinh;
-    using glm::atan;
-    using glm::atanh;
-    using glm::cos;
-    using glm::cosh;
-    using glm::degrees;
-    using glm::radians;
-    using glm::sin;
-    using glm::sinh;
-    using glm::tan;
-    using glm::tanh;
-
-    using glm::vec;
-
-    using glm::bvec2;
-    using glm::dvec2;
-    using glm::highp_bvec2;
-    using glm::highp_dvec2;
-    using glm::highp_ivec2;
-    using glm::highp_uvec2;
-    using glm::highp_vec2;
-    using glm::ivec2;
-    using glm::lowp_bvec2;
-    using glm::lowp_dvec2;
-    using glm::lowp_ivec2;
-    using glm::lowp_uvec2;
-    using glm::lowp_vec2;
-    using glm::mediump_bvec2;
-    using glm::mediump_dvec2;
-    using glm::mediump_ivec2;
-    using glm::mediump_uvec2;
-    using glm::mediump_vec2;
-    using glm::uvec2;
-    using glm::vec2;
-
-    using glm::bvec3;
-    using glm::dvec3;
-    using glm::highp_bvec3;
-    using glm::highp_dvec3;
-    using glm::highp_ivec3;
-    using glm::highp_uvec3;
-    using glm::highp_vec3;
-    using glm::ivec3;
-    using glm::lowp_bvec3;
-    using glm::lowp_dvec3;
-    using glm::lowp_ivec3;
-    using glm::lowp_uvec3;
-    using glm::lowp_vec3;
-    using glm::mediump_bvec3;
-    using glm::mediump_dvec3;
-    using glm::mediump_ivec3;
-    using glm::mediump_uvec3;
-    using glm::mediump_vec3;
-    using glm::uvec3;
-    using glm::vec3;
-
-    using glm::bvec4;
-    using glm::dvec4;
-    using glm::highp_bvec4;
-    using glm::highp_dvec4;
-    using glm::highp_ivec4;
-    using glm::highp_uvec4;
-    using glm::highp_vec4;
-    using glm::ivec4;
-    using glm::lowp_bvec4;
-    using glm::lowp_dvec4;
-    using glm::lowp_ivec4;
-    using glm::lowp_uvec4;
-    using glm::lowp_vec4;
-    using glm::mediump_bvec4;
-    using glm::mediump_dvec4;
-    using glm::mediump_ivec4;
-    using glm::mediump_uvec4;
-    using glm::mediump_vec4;
-    using glm::uvec4;
-    using glm::vec4;
-
-    using glm::all;
-    using glm::any;
-    using glm::equal;
-    using glm::greaterThan;
-    using glm::greaterThanEqual;
-    using glm::lessThan;
-    using glm::lessThanEqual;
-    using glm::not_;
-    using glm::notEqual;
-
-    using glm::angleAxis;
-    using glm::axis;
-    using glm::conjugate;
-    using glm::inverse;
-    using glm::isinf;
-    using glm::isnan;
-    using glm::lerp;
-    using glm::mix;
-    using glm::rotate;
-    using glm::slerp;
-    using glm::translate;
-
-    /* integer.hpp */
-    using glm::bitCount;
-    using glm::bitfieldExtract;
-    using glm::bitfieldInsert;
-    using glm::bitfieldReverse;
-    using glm::findLSB;
-    using glm::findMSB;
-    using glm::imulExtended;
-    using glm::uaddCarry;
-    using glm::umulExtended;
-    using glm::usubBorrow;
-
-    /* gtc/quaternion.hpp */
-    using glm::qua;
-
-    using glm::dquat;
-    using glm::highp_dquat;
-    using glm::highp_quat;
-    using glm::lowp_dquat;
-    using glm::lowp_quat;
-    using glm::mediump_dquat;
-    using glm::mediump_quat;
-    using glm::quat;
-
-    using glm::eulerAngles;
-    using glm::mat3_cast;
-    using glm::mat4_cast;
-    using glm::pitch;
-    using glm::quat_cast;
-    using glm::quatLookAt;
-    using glm::quatLookAtLH;
-    using glm::quatLookAtRH;
-    using glm::roll;
-    using glm::yaw;
-} // namespace glm
\ No newline at end of file
diff --git a/modules/stormkit/Core/Utils/Functional.mpp b/modules/stormkit/Core/Utils/Functional.mpp
index 1b97b740..40054b6d 100644
--- a/modules/stormkit/Core/Utils/Functional.mpp
+++ b/modules/stormkit/Core/Utils/Functional.mpp
@@ -24,12 +24,11 @@ export namespace stormkit::core {
                std::invocable auto&& false_) noexcept -> decltype(auto);
 
     template<typename T, typename U>
-    [[nodiscard]] constexpr auto isEqual(T&& a, U&& b) noexcept -> bool;
+    [[nodiscard]] constexpr auto isEqual(const T& a, const U& b) noexcept -> bool;
 
     template<typename Func, typename... Args>
-        // requires(std::invocable<Func, Args...>)
-    [[nodiscard]] constexpr auto toUnary(Func&& func,
-                                         Args&&...args) noexcept -> decltype(auto);
+    // requires(std::invocable<Func, Args...>)
+    [[nodiscard]] constexpr auto toUnary(Func&& func, Args&&...args) noexcept -> decltype(auto);
 } // namespace stormkit::core
 
 ////////////////////////////////////////////////////////////////////
@@ -61,14 +60,14 @@ namespace stormkit::core {
     /////////////////////////////////////
     /////////////////////////////////////
     template<typename T, typename U>
-    STORMKIT_FORCE_INLINE constexpr auto isEqual(T&& a, U&& b) noexcept -> bool {
+    STORMKIT_FORCE_INLINE constexpr auto isEqual(const T& a, const U& b) noexcept -> bool {
         return a == b;
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
     template<typename Func, typename... Args>
-        // requires(std::invocable<Func, Args...>)
+    // requires(std::invocable<Func, Args...>)
     STORMKIT_FORCE_INLINE constexpr auto toUnary(Func&& func,
                                                  Args&&...args) noexcept -> decltype(auto) {
         return [_func = std::forward<Func>(func), ... _args = std::forward<Args>(args)](
diff --git a/modules/stormkit/Core/Utils/Monadic.mpp b/modules/stormkit/Core/Utils/Monadic.mpp
index cd1e0128..56d20dc0 100644
--- a/modules/stormkit/Core/Utils/Monadic.mpp
+++ b/modules/stormkit/Core/Utils/Monadic.mpp
@@ -13,6 +13,7 @@ import std;
 import :Meta;
 
 import :Utils.AsCast;
+import :Utils.Functional;
 
 export namespace stormkit::core::monadic {
     struct Anything {
diff --git a/modules/stormkit/Gpu/Core/Device.mpp b/modules/stormkit/Gpu/Core/Device.mpp
index efa7c9a5..6474aee7 100644
--- a/modules/stormkit/Gpu/Core/Device.mpp
+++ b/modules/stormkit/Gpu/Core/Device.mpp
@@ -12,7 +12,6 @@ import std;
 
 import stormkit.Core;
 
-
 import stormkit.Gpu.Vulkan;
 
 import :Core.Types;
@@ -41,8 +40,8 @@ export namespace stormkit::gpu {
         };
 
         Device(const PhysicalDevice& physical_device,
-               const Instance      & instance,
-               const Info          & info,
+               const Instance&       instance,
+               const Info&           info,
                Tag);
         ~Device();
 
@@ -53,29 +52,28 @@ export namespace stormkit::gpu {
         auto operator=(Device&&) noexcept -> Device&;
 
         [[nodiscard]] static auto create(const PhysicalDevice& physical_device,
-                                         const Instance      & instance,
+                                         const Instance&       instance,
                                          const Info& info = { true, false }) noexcept -> Device;
-        [[nodiscard]] static auto allocate(const PhysicalDevice& physical_device,
-                                           const Instance      & instance,
-                                           const Info          & info = { true, false }) noexcept
-            -> std::unique_ptr<Device>;
+        [[nodiscard]] static auto
+            allocate(const PhysicalDevice& physical_device,
+                     const Instance&       instance,
+                     const Info& info = { true, false }) noexcept -> std::unique_ptr<Device>;
 
         auto waitIdle() const noexcept -> void;
 
-        [[nodiscard]] auto waitForFences(std::span<const core::NakedRef<const Fence>> fences,
-                                         bool                             wait_all = true,
-                                         const std::chrono::milliseconds& timeout =
-                                             std::chrono::milliseconds::max()) const noexcept
-            -> Expected<Result>;
-        [[nodiscard]] auto waitForFence(const Fence                    & fence,
-                                        const std::chrono::milliseconds& timeout =
-                                            std::chrono::milliseconds::max()) const noexcept
-            -> Expected<Result>;
-
         [[nodiscard]] auto
-            resetFences(std::span<const core::NakedRef<const Fence>> fences) const noexcept
-            -> Expected<void>;
-        [[nodiscard]] auto resetFence(const Fence& fence) const noexcept -> Expected<void>;
+            waitForFences(std::span<const core::NakedRef<const Fence>> fences,
+                          bool                                         wait_all = true,
+                          const std::chrono::milliseconds&             timeout =
+                              std::chrono::milliseconds::max()) const noexcept -> Expected<Result>;
+        [[nodiscard]] auto
+            waitForFence(const Fence&                     fence,
+                         const std::chrono::milliseconds& timeout =
+                             std::chrono::milliseconds::max()) const noexcept -> Expected<Result>;
+
+        auto
+            resetFences(std::span<const core::NakedRef<const Fence>> fences) const noexcept -> void;
+        auto resetFence(const Fence& fence) const noexcept -> void;
 
         [[nodiscard]] auto rasterQueueEntry() const noexcept -> const QueueEntry&;
         [[nodiscard]] auto asyncTransfertQueueEntry() const noexcept -> const QueueEntry&;
@@ -92,10 +90,11 @@ export namespace stormkit::gpu {
         [[nodiscard]] auto vmaFunctionTable() const noexcept -> const vma::VulkanFunctions&;
 
         template<class T>
-        auto setObjectName(const T& object, std::string_view name) const -> Expected<void>;
+        auto setObjectName(const T& object, std::string_view name) const -> void;
 
-        auto setObjectName(core::UInt64 object, DebugObjectType type, std::string_view name) const
-            -> Expected<void>;
+        auto setObjectName(core::UInt64     object,
+                           DebugObjectType  type,
+                           std::string_view name) const -> void;
 
       private:
         core::NakedRef<const PhysicalDevice> m_physical_device;
@@ -138,18 +137,16 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto
-        Device::waitForFence(const Fence                    & fence,
-                             const std::chrono::milliseconds& timeout) const noexcept
-        -> Expected<Result> {
+    STORMKIT_FORCE_INLINE auto Device::waitForFence(
+        const Fence&                     fence,
+        const std::chrono::milliseconds& timeout) const noexcept -> Expected<Result> {
         return waitForFences(core::makeNakedRefArray(fence), true, timeout);
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Device::resetFence(const Fence& fence) const noexcept
-        -> Expected<void> {
-        return resetFences(core::makeNakedRefArray(fence));
+    STORMKIT_FORCE_INLINE auto Device::resetFence(const Fence& fence) const noexcept -> void {
+        resetFences(core::makeNakedRefArray(fence));
     }
 
     /////////////////////////////////////
@@ -160,8 +157,8 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Device::asyncTransfertQueueEntry() const noexcept
-        -> const QueueEntry& {
+    STORMKIT_FORCE_INLINE auto
+        Device::asyncTransfertQueueEntry() const noexcept -> const QueueEntry& {
         core::expects(m_async_transfert_queue != std::nullopt);
 
         return *m_async_transfert_queue;
@@ -169,8 +166,8 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Device::asyncComputeQueueEntry() const noexcept
-        -> const QueueEntry& {
+    STORMKIT_FORCE_INLINE auto
+        Device::asyncComputeQueueEntry() const noexcept -> const QueueEntry& {
         core::expects(m_async_compute_queue != std::nullopt);
 
         return *m_async_compute_queue;
@@ -210,18 +207,31 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Device::vmaFunctionTable() const noexcept
-        -> const vma::VulkanFunctions& {
+    STORMKIT_FORCE_INLINE auto
+        Device::vmaFunctionTable() const noexcept -> const vma::VulkanFunctions& {
         return m_vma_function_table;
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
     template<class T>
-    STORMKIT_FORCE_INLINE auto Device::setObjectName(const T& object, std::string_view name) const
-        -> Expected<void> {
-        return setObjectName(std::bit_cast<core::UInt64>(*(object.vkHandle())),
-                             T::DEBUG_TYPE,
-                             name);
+    STORMKIT_FORCE_INLINE auto Device::setObjectName(const T&         object,
+                                                     std::string_view name) const -> void {
+        setObjectName(std::bit_cast<core::UInt64>(*(object.vkHandle())), T::DEBUG_TYPE, name);
+    }
+
+    /////////////////////////////////////
+    /////////////////////////////////////
+    STORMKIT_FORCE_INLINE auto Device::setObjectName(core::UInt64     object,
+                                                     DebugObjectType  type,
+                                                     std::string_view name) const -> void {
+        if (!vkHandle().getDispatcher()->vkSetDebugUtilsObjectNameEXT) return;
+
+        const auto info = vk::DebugUtilsObjectNameInfoEXT {}
+                              .setObjectType(core::narrow<vk::ObjectType>(type))
+                              .setObjectHandle(object)
+                              .setPObjectName(std::data(name));
+
+        m_vk_device->setDebugUtilsObjectNameEXT(info);
     }
 } // namespace stormkit::gpu
diff --git a/modules/stormkit/Gpu/Core/Sync.mpp b/modules/stormkit/Gpu/Core/Sync.mpp
index 7d3cef1b..4a66c29b 100644
--- a/modules/stormkit/Gpu/Core/Sync.mpp
+++ b/modules/stormkit/Gpu/Core/Sync.mpp
@@ -12,7 +12,6 @@ import std;
 
 import stormkit.Core;
 
-
 import stormkit.Gpu.Vulkan;
 
 import :Core.Types;
@@ -41,18 +40,17 @@ export namespace stormkit::gpu {
         Fence(Fence&&) noexcept;
         auto operator=(Fence&&) noexcept -> Fence&;
 
-        [[nodiscard]] static auto create(const Device& device, bool signaled = false) noexcept
-            -> Expected<Fence>;
+        [[nodiscard]] static auto create(const Device& device,
+                                         bool signaled = false) noexcept -> Expected<Fence>;
         [[nodiscard]] static auto createSignaled(const Device& device) noexcept -> Expected<Fence>;
         [[nodiscard]] static auto allocate(const Device& device, bool signaled = false) noexcept
             -> Expected<std::unique_ptr<Fence>>;
-        [[nodiscard]] static auto allocateSignaled(const Device& device) noexcept
-            -> Expected<std::unique_ptr<Fence>>;
+        [[nodiscard]] static auto
+            allocateSignaled(const Device& device) noexcept -> Expected<std::unique_ptr<Fence>>;
 
-        [[nodiscard]] auto
-            wait(const std::chrono::milliseconds& wait_for = std::chrono::milliseconds::max()) const
-            -> Expected<Result>;
-        [[nodiscard]] auto reset() -> Expected<void>;
+        [[nodiscard]] auto wait(const std::chrono::milliseconds& wait_for =
+                                    std::chrono::milliseconds::max()) const -> Expected<Result>;
+        auto               reset() -> void;
 
         [[nodiscard]] auto status() const noexcept -> Expected<Status>;
 
@@ -78,8 +76,8 @@ export namespace stormkit::gpu {
         auto operator=(Semaphore&&) noexcept -> Semaphore&;
 
         [[nodiscard]] auto create(const Device& device) noexcept -> Expected<Semaphore>;
-        [[nodiscard]] auto allocate(const Device& device) noexcept
-            -> Expected<std::unique_ptr<Semaphore>>;
+        [[nodiscard]] auto
+            allocate(const Device& device) noexcept -> Expected<std::unique_ptr<Semaphore>>;
 
         [[nodiscard]] auto vkHandle() const noexcept -> const vk::raii::Semaphore&;
 
@@ -102,9 +100,12 @@ namespace stormkit::gpu {
 
         const auto create_info = vk::FenceCreateInfo {}.setFlags(flags);
 
-        vkCreate<vk::raii::Fence>(this->device().vkHandle(), create_info)
+        this->device()
+            .vkHandle()
+            .createFence(create_info)
             .transform(core::monadic::set(m_vk_fence))
-            .transform_error(core::monadic::map(core::monadic::narrow<Result>(), core::throwError()));
+            .transform_error(
+                core::monadic::map(core::monadic::narrow<Result>(), core::throwError()));
     }
 
     /////////////////////////////////////
@@ -122,28 +123,27 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE auto Fence::status() const noexcept -> Expected<Status> {
-        return vkCall(*m_vk_fence, &vk::raii::Fence::getStatus)
-            .transform([](auto&& status) noexcept {
-                if (status == vk::Result::eSuccess) return Status::Signaled;
-                else if (status == vk::Result::eNotReady)
-                    return Status::Unsignaled;
-
-                std::unreachable();
+        return vkCall(*m_vk_fence,
+                      &vk::raii::Fence::getStatus,
+                      { { vk::Result::eSuccess, vk::Result::eNotReady } })
+            .transform([](auto&& result) noexcept {
+                if (result == vk::Result::eNotReady) return Status::Unsignaled;
+                return Status::Signaled;
             })
             .transform_error(core::monadic::narrow<Result>());
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Fence::create(const Device& device, bool signaled) noexcept
-        -> Expected<Fence> try {
+    STORMKIT_FORCE_INLINE auto Fence::create(const Device& device,
+                                             bool signaled) noexcept -> Expected<Fence> try {
         return Fence { device, signaled, Tag {} };
     } catch (const Result& result) { return std::unexpected(result); }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Fence::createSignaled(const Device& device) noexcept
-        -> Expected<Fence> {
+    STORMKIT_FORCE_INLINE auto
+        Fence::createSignaled(const Device& device) noexcept -> Expected<Fence> {
         return create(device, true);
     }
 
@@ -156,22 +156,22 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Fence::allocateSignaled(const Device& device) noexcept
-        -> Expected<std::unique_ptr<Fence>> {
+    STORMKIT_FORCE_INLINE auto
+        Fence::allocateSignaled(const Device& device) noexcept -> Expected<std::unique_ptr<Fence>> {
         return allocate(device, true);
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Fence::wait(const std::chrono::milliseconds& wait_for) const
-        -> Expected<Result> {
+    STORMKIT_FORCE_INLINE auto
+        Fence::wait(const std::chrono::milliseconds& wait_for) const -> Expected<Result> {
         return device().waitForFence(*this, wait_for);
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Fence::reset() -> Expected<void> {
-        return device().resetFence(*this);
+    STORMKIT_FORCE_INLINE auto Fence::reset() -> void {
+        device().resetFence(*this);
     }
 
     /////////////////////////////////////
@@ -186,9 +186,12 @@ namespace stormkit::gpu {
         : DeviceObject { device } {
         const auto create_info = vk::SemaphoreCreateInfo {};
 
-        vkCreate<vk::raii::Semaphore>(this->device().vkHandle(), create_info)
+        this->device()
+            .vkHandle()
+            .createSemaphore(create_info)
             .transform(core::monadic::set(m_vk_semaphore))
-            .transform_error(core::monadic::map(core::monadic::narrow<Result>(), core::throwError()));
+            .transform_error(
+                core::monadic::map(core::monadic::narrow<Result>(), core::throwError()));
     };
 
     /////////////////////////////////////
@@ -201,13 +204,13 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Semaphore::operator=(Semaphore&& other) noexcept
-        -> Semaphore& = default;
+    STORMKIT_FORCE_INLINE auto
+        Semaphore::operator=(Semaphore&& other) noexcept -> Semaphore& = default;
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Semaphore::create(const Device& device) noexcept
-        -> Expected<Semaphore> try {
+    STORMKIT_FORCE_INLINE auto
+        Semaphore::create(const Device& device) noexcept -> Expected<Semaphore> try {
         return Semaphore { device, Tag {} };
     } catch (const Result& result) { return std::unexpected(result); }
 
diff --git a/modules/stormkit/Gpu/Core/Types.mpp b/modules/stormkit/Gpu/Core/Types.mpp
index 056f6bee..f18a8fdf 100644
--- a/modules/stormkit/Gpu/Core/Types.mpp
+++ b/modules/stormkit/Gpu/Core/Types.mpp
@@ -977,9 +977,6 @@ export {
         using ClearValue = std::variant<ClearColor, ClearDepthStencil>;
         using SpirvID    = core::UInt32;
 
-        template<class T>
-        using Expected = std::expected<T, Result>;
-
         template<typename T>
         class ParentRef {
           public:
@@ -998,6 +995,9 @@ export {
             core::NakedRef<const T> m_parent;
         };
 
+        template<class T>
+        using Expected = std::expected<T, Result>;
+
         class Instance;
 
         class InstanceObject: public ParentRef<Instance> {
diff --git a/modules/stormkit/Gpu/Execution/CommandBuffer.mpp b/modules/stormkit/Gpu/Execution/CommandBuffer.mpp
index 210e0187..2f9cf95f 100644
--- a/modules/stormkit/Gpu/Execution/CommandBuffer.mpp
+++ b/modules/stormkit/Gpu/Execution/CommandBuffer.mpp
@@ -52,8 +52,7 @@ export namespace stormkit::gpu {
         auto submit(std::span<core::NakedRef<const CommandBuffer>> commandbuffers,
                     std::span<core::NakedRef<const Semaphore>>     wait_semaphores   = {},
                     std::span<core::NakedRef<const Semaphore>>     signal_semaphores = {},
-                    core::OptionalRef<const Fence> fence = std::nullopt) const noexcept
-            -> Expected<void>;
+                    core::OptionalRef<const Fence> fence = std::nullopt) const noexcept -> void;
 
         [[nodiscard]] auto entry() const noexcept -> const Device::QueueEntry&;
 
@@ -111,11 +110,10 @@ export namespace stormkit::gpu {
         CommandBuffer(CommandBuffer&&) noexcept;
         auto operator=(CommandBuffer&&) noexcept -> CommandBuffer&;
 
-        auto reset() noexcept -> Expected<void>;
+        auto reset() noexcept -> void;
         auto submit(std::span<core::NakedRef<const Semaphore>> wait_semaphores   = {},
                     std::span<core::NakedRef<const Semaphore>> signal_semaphores = {},
-                    core::OptionalRef<const Fence>             fence = std::nullopt) const noexcept
-            -> Expected<void>;
+                    core::OptionalRef<const Fence> fence = std::nullopt) const noexcept -> void;
 
         [[nodiscard]] auto state() const noexcept -> State;
         [[nodiscard]] auto level() const noexcept -> CommandBufferLevel;
@@ -351,7 +349,9 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE Queue::Queue(const Device& device, const Device::QueueEntry& entry, Tag)
         : DeviceObject { device }, m_entry { entry } {
-        vkCall(toRaiiVkHandle()(this->device()), &vk::raii::Device::getQueue, entry.id, 0)
+        this->device()
+            .vkHandle()
+            .getQueue(entry.id, 0)
             .transform(core::monadic::set(m_vk_queue))
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
@@ -384,7 +384,7 @@ namespace stormkit::gpu {
         Queue::submit(std::span<core::NakedRef<const CommandBuffer>> command_buffers,
                       std::span<core::NakedRef<const Semaphore>>     wait_semaphores,
                       std::span<core::NakedRef<const Semaphore>>     signal_semaphores,
-                      core::OptionalRef<const Fence> fence) const noexcept -> Expected<void> {
+                      core::OptionalRef<const Fence>                 fence) const noexcept -> void {
         const auto vk_command_buffers =
             command_buffers | std::views::transform(toVkHandle()) | std::ranges::to<std::vector>();
         const auto vk_wait_semaphores =
@@ -402,8 +402,7 @@ namespace stormkit::gpu {
                          core::monadic::map(toVkHandle(), core::monadic::init<vk::Fence>()),
                          core::monadic::init<vk::Fence>());
 
-        return vkCall(toRaiiVkHandle()(*this), &vk::raii::Queue::submit, submit_infos, vk_fence)
-            .transform_error(core::monadic::as<Result>());
+        vkHandle().submit(submit_infos, vk_fence);
     }
 
     /////////////////////////////////////
@@ -445,12 +444,9 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto CommandBuffer::reset() noexcept -> Expected<void> {
-        return vkCall(toRaiiVkHandle()(*this),
-                      &vk::raii::CommandBuffer::reset,
-                      vk::CommandBufferResetFlagBits {})
-            .transform([this]() noexcept { m_state = State::Initial; })
-            .transform_error(core::monadic::as<Result>());
+    STORMKIT_FORCE_INLINE auto CommandBuffer::reset() noexcept -> void {
+        vkHandle().reset(vk::CommandBufferResetFlagBits {});
+        m_state = State::Initial;
     }
 
     /////////////////////////////////////
@@ -459,10 +455,10 @@ namespace stormkit::gpu {
     auto CommandBuffer::submit(std::span<core::NakedRef<const Semaphore>> wait_semaphores,
                                std::span<core::NakedRef<const Semaphore>> signal_semaphores,
                                core::OptionalRef<const Fence>             fence) const noexcept
-        -> Expected<void> {
+        -> void {
         auto cmbs = std::array { core::NakedRef<const CommandBuffer> { *this } };
 
-        return queue().submit(cmbs, wait_semaphores, signal_semaphores, std::move(fence));
+        queue().submit(cmbs, wait_semaphores, signal_semaphores, std::move(fence));
     }
 
     /////////////////////////////////////
diff --git a/modules/stormkit/Gpu/Execution/Descriptors.mpp b/modules/stormkit/Gpu/Execution/Descriptors.mpp
index e330df3a..51e27abe 100644
--- a/modules/stormkit/Gpu/Execution/Descriptors.mpp
+++ b/modules/stormkit/Gpu/Execution/Descriptors.mpp
@@ -303,7 +303,7 @@ namespace stormkit::gpu {
 
         const auto create_info = vk::DescriptorSetLayoutCreateInfo {}.setBindings(vk_bindings);
 
-        vkCreate<vk::raii::DescriptorSetLayout>(this->device().vkHandle(), create_info)
+        this->device().vkHandle().createDescriptorSetLayout(create_info)
             .transform(core::monadic::set(m_vk_descriptor_set_layout))
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
@@ -389,7 +389,7 @@ namespace stormkit::gpu {
                                      .setMaxSets(max_sets)
                                      .setPoolSizes(pool_sizes);
 
-        vkCreate<vk::raii::DescriptorPool>(this->device().vkHandle(), create_info)
+        this->device().vkHandle().createDescriptorPool(create_info)
             .transform(core::monadic::set(m_vk_descriptor_pool))
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
diff --git a/modules/stormkit/Gpu/Execution/Pipeline.mpp b/modules/stormkit/Gpu/Execution/Pipeline.mpp
index f80c475f..dadc2c1c 100644
--- a/modules/stormkit/Gpu/Execution/Pipeline.mpp
+++ b/modules/stormkit/Gpu/Execution/Pipeline.mpp
@@ -10,7 +10,6 @@ export module stormkit.Gpu:Execution.Pipeline;
 
 import std;
 
-
 import stormkit.Core;
 
 import :Core;
@@ -37,10 +36,10 @@ export namespace stormkit::gpu {
         PipelineCache(PipelineCache&&) noexcept;
         auto operator=(PipelineCache&&) noexcept -> PipelineCache&;
 
-        [[nodiscard]] static auto create(const Device        & device,
-                                         std::filesystem::path cache_path) noexcept
-            -> Expected<PipelineCache>;
-        [[nodiscard]] static auto allocate(const Device        & device,
+        [[nodiscard]] static auto
+                                  create(const Device&         device,
+                                         std::filesystem::path cache_path) noexcept -> Expected<PipelineCache>;
+        [[nodiscard]] static auto allocate(const Device&         device,
                                            std::filesystem::path cache_path) noexcept
             -> Expected<std::unique_ptr<PipelineCache>>;
 
@@ -92,10 +91,10 @@ export namespace stormkit::gpu {
         PipelineLayout(PipelineLayout&&) noexcept;
         auto operator=(PipelineLayout&&) noexcept -> PipelineLayout&;
 
-        [[nodiscard]] static auto create(const Device              & device,
-                                         const RasterPipelineLayout& layout) noexcept
-            -> Expected<PipelineLayout>;
-        [[nodiscard]] static auto allocate(const Device              & device,
+        [[nodiscard]] static auto
+                                  create(const Device&               device,
+                                         const RasterPipelineLayout& layout) noexcept -> Expected<PipelineLayout>;
+        [[nodiscard]] static auto allocate(const Device&               device,
                                            const RasterPipelineLayout& layout) noexcept
             -> Expected<std::unique_ptr<PipelineLayout>>;
 
@@ -119,10 +118,10 @@ export namespace stormkit::gpu {
 
         static constexpr auto DEBUG_TYPE = DebugObjectType::Pipeline;
 
-        Pipeline(const Device                                     & device,
-                 const RasterPipelineState                        & state,
-                 const PipelineLayout                             & layout,
-                 const RenderPass                                 & render_pass,
+        Pipeline(const Device&                                      device,
+                 const RasterPipelineState&                         state,
+                 const PipelineLayout&                              layout,
+                 const RenderPass&                                  render_pass,
                  std::optional<core::NakedRef<const PipelineCache>> cache,
                  Tag);
         ~Pipeline();
@@ -134,17 +133,17 @@ export namespace stormkit::gpu {
         auto operator=(Pipeline&&) noexcept -> Pipeline&;
 
         [[nodiscard]] static auto
-            create(const Device                                     & device,
-                   const RasterPipelineState                        & state,
-                   const PipelineLayout                             & layout,
-                   const RenderPass                                 & render_pass,
+            create(const Device&                                      device,
+                   const RasterPipelineState&                         state,
+                   const PipelineLayout&                              layout,
+                   const RenderPass&                                  render_pass,
                    std::optional<core::NakedRef<const PipelineCache>> cache) noexcept
             -> Expected<Pipeline>;
         [[nodiscard]] static auto
-            allocate(const Device                                     & device,
-                     const RasterPipelineState                        & state,
-                     const PipelineLayout                             & layout,
-                     const RenderPass                                 & render_pass,
+            allocate(const Device&                                      device,
+                     const RasterPipelineState&                         state,
+                     const PipelineLayout&                              layout,
+                     const RenderPass&                                  render_pass,
                      std::optional<core::NakedRef<const PipelineCache>> cache) noexcept
             -> Expected<std::unique_ptr<Pipeline>>;
 
@@ -198,12 +197,12 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineCache::operator=(PipelineCache&& other) noexcept
-        -> PipelineCache& = default;
+    STORMKIT_FORCE_INLINE auto
+        PipelineCache::operator=(PipelineCache&& other) noexcept -> PipelineCache& = default;
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineCache::create(const Device        & device,
+    STORMKIT_FORCE_INLINE auto PipelineCache::create(const Device&         device,
                                                      std::filesystem::path cache_path) noexcept
         -> Expected<PipelineCache> try {
         return PipelineCache { device, std::move(cache_path), Tag {} };
@@ -211,7 +210,7 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineCache::allocate(const Device        & device,
+    STORMKIT_FORCE_INLINE auto PipelineCache::allocate(const Device&         device,
                                                        std::filesystem::path cache_path) noexcept
         -> Expected<std::unique_ptr<PipelineCache>> try {
         return std::make_unique<PipelineCache>(device, std::move(cache_path), Tag {});
@@ -219,8 +218,8 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineCache::vkHandle() const noexcept
-        -> const vk::raii::PipelineCache& {
+    STORMKIT_FORCE_INLINE auto
+        PipelineCache::vkHandle() const noexcept -> const vk::raii::PipelineCache& {
         return m_vk_pipeline_cache;
     }
 
@@ -237,7 +236,8 @@ namespace stormkit::gpu {
             m_layout.push_constant_ranges |
             std::views::transform([](auto&& push_constant_range) noexcept {
                 return vk::PushConstantRange {}
-                    .setStageFlags(core::narrow<vk::ShaderStageFlagBits>(push_constant_range.stages))
+                    .setStageFlags(
+                        core::narrow<vk::ShaderStageFlagBits>(push_constant_range.stages))
                     .setOffset(push_constant_range.offset)
                     .setSize(core::as<core::UInt32>(push_constant_range.size));
             }) |
@@ -247,7 +247,9 @@ namespace stormkit::gpu {
                                      .setSetLayouts(set_layouts)
                                      .setPushConstantRanges(push_constant_ranges);
 
-        vkCreate<vk::raii::PipelineLayout>(toRaiiVkHandle()(this->device()), create_info)
+        this->device()
+            .vkHandle()
+            .createPipelineLayout(create_info)
             .transform(core::monadic::set(m_vk_pipeline_layout))
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
@@ -262,12 +264,12 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineLayout::operator=(PipelineLayout&& other) noexcept
-        -> PipelineLayout& = default;
+    STORMKIT_FORCE_INLINE auto
+        PipelineLayout::operator=(PipelineLayout&& other) noexcept -> PipelineLayout& = default;
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineLayout::create(const Device              & device,
+    STORMKIT_FORCE_INLINE auto PipelineLayout::create(const Device&               device,
                                                       const RasterPipelineLayout& layout) noexcept
         -> Expected<PipelineLayout> try {
         return PipelineLayout { device, layout, Tag {} };
@@ -275,7 +277,7 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineLayout::allocate(const Device              & device,
+    STORMKIT_FORCE_INLINE auto PipelineLayout::allocate(const Device&               device,
                                                         const RasterPipelineLayout& layout) noexcept
         -> Expected<std::unique_ptr<PipelineLayout>> try {
         return std::make_unique<PipelineLayout>(device, layout, Tag {});
@@ -283,18 +285,18 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto PipelineLayout::vkHandle() const noexcept
-        -> const vk::raii::PipelineLayout& {
+    STORMKIT_FORCE_INLINE auto
+        PipelineLayout::vkHandle() const noexcept -> const vk::raii::PipelineLayout& {
         return m_vk_pipeline_layout;
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE
-    Pipeline::Pipeline(const Device                                     & device,
-                       const RasterPipelineState                        & state,
-                       const PipelineLayout                             & layout,
-                       const RenderPass                                 & render_pass,
+    Pipeline::Pipeline(const Device&                                      device,
+                       const RasterPipelineState&                         state,
+                       const PipelineLayout&                              layout,
+                       const RenderPass&                                  render_pass,
                        std::optional<core::NakedRef<const PipelineCache>> cache,
                        Tag)
         : DeviceObject { device }, m_state { state } {
@@ -312,16 +314,16 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Pipeline::operator=(Pipeline&& other) noexcept
-        -> Pipeline& = default;
+    STORMKIT_FORCE_INLINE auto
+        Pipeline::operator=(Pipeline&& other) noexcept -> Pipeline& = default;
 
     /////////////////////////////////////
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE auto
-        Pipeline::create(const Device                                     & device,
-                         const RasterPipelineState                        & state,
-                         const PipelineLayout                             & layout,
-                         const RenderPass                                 & render_pass,
+        Pipeline::create(const Device&                                      device,
+                         const RasterPipelineState&                         state,
+                         const PipelineLayout&                              layout,
+                         const RenderPass&                                  render_pass,
                          std::optional<core::NakedRef<const PipelineCache>> cache) noexcept
         -> Expected<Pipeline> try {
         return Pipeline { device, state, layout, render_pass, std::move(cache), Tag {} };
@@ -330,10 +332,10 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE auto
-        Pipeline::allocate(const Device                                     & device,
-                           const RasterPipelineState                        & state,
-                           const PipelineLayout                             & layout,
-                           const RenderPass                                 & render_pass,
+        Pipeline::allocate(const Device&                                      device,
+                           const RasterPipelineState&                         state,
+                           const PipelineLayout&                              layout,
+                           const RenderPass&                                  render_pass,
                            std::optional<core::NakedRef<const PipelineCache>> cache) noexcept
         -> Expected<std::unique_ptr<Pipeline>> try {
         return std::make_unique<Pipeline>(device,
@@ -352,8 +354,8 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Pipeline::rasterState() const noexcept
-        -> const RasterPipelineState& {
+    STORMKIT_FORCE_INLINE auto
+        Pipeline::rasterState() const noexcept -> const RasterPipelineState& {
         core::expects(core::is<RasterPipelineState>(m_state));
         return core::as<RasterPipelineState>(m_state);
     }
diff --git a/modules/stormkit/Gpu/Execution/RenderPass.mpp b/modules/stormkit/Gpu/Execution/RenderPass.mpp
index ae5a832c..df7755ef 100644
--- a/modules/stormkit/Gpu/Execution/RenderPass.mpp
+++ b/modules/stormkit/Gpu/Execution/RenderPass.mpp
@@ -202,7 +202,7 @@ namespace stormkit::gpu {
                                      .setHeight(m_extent.height)
                                      .setLayers(1);
 
-        vkCreate<vk::raii::Framebuffer>(toRaiiVkHandle()(device()), create_info)
+        device().vkHandle().createFramebuffer(create_info)
             .transform(core::monadic::set(m_vk_framebuffer))
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
diff --git a/modules/stormkit/Gpu/Resource/Image.mpp b/modules/stormkit/Gpu/Resource/Image.mpp
index 996f6e9b..ab363c8e 100644
--- a/modules/stormkit/Gpu/Resource/Image.mpp
+++ b/modules/stormkit/Gpu/Resource/Image.mpp
@@ -218,25 +218,24 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE Sampler::Sampler(const Device& device, const Settings& settings, Tag)
         : DeviceObject { device }, m_settings { settings } {
-        auto create_info =
-            vk::SamplerCreateInfo {}
-                .setMagFilter(core::narrow<vk::Filter>(m_settings.mag_filter))
-                .setMinFilter(core::narrow<vk::Filter>(m_settings.min_filter))
-                .setMipmapMode(core::narrow<vk::SamplerMipmapMode>(m_settings.mipmap_mode))
-                .setAddressModeU(core::narrow<vk::SamplerAddressMode>(m_settings.address_mode_u))
-                .setAddressModeV(core::narrow<vk::SamplerAddressMode>(m_settings.address_mode_v))
-                .setAddressModeW(core::narrow<vk::SamplerAddressMode>(m_settings.address_mode_w))
-                .setMipLodBias(m_settings.mip_lod_bias)
-                .setAnisotropyEnable(m_settings.enable_anisotropy)
-                .setMaxAnisotropy(m_settings.max_anisotropy)
-                .setCompareEnable(m_settings.compare_enable)
-                .setCompareOp(core::narrow<vk::CompareOp>(m_settings.compare_operation))
-                .setMinLod(m_settings.min_lod)
-                .setMaxLod(m_settings.max_lod)
-                .setBorderColor(core::narrow<vk::BorderColor>(m_settings.border_color))
-                .setUnnormalizedCoordinates(m_settings.unnormalized_coordinates);
-
-        vkCreate<vk::raii::Sampler>(this->device().vkHandle(), std::move(create_info))
+        this->device()
+            .vkHandle()
+            .createSampler(
+                { .magFilter    = core::narrow<vk::Filter>(m_settings.mag_filter),
+                  .minFilter    = core::narrow<vk::Filter>(m_settings.min_filter),
+                  .mipmapMode   = core::narrow<vk::SamplerMipmapMode>(m_settings.mipmap_mode),
+                  .addressModeU = core::narrow<vk::SamplerAddressMode>(m_settings.address_mode_u),
+                  .addressModeV = core::narrow<vk::SamplerAddressMode>(m_settings.address_mode_v),
+                  .addressModeW = core::narrow<vk::SamplerAddressMode>(m_settings.address_mode_w),
+                  .mipLodBias   = m_settings.mip_lod_bias,
+                  .anisotropyEnable = m_settings.enable_anisotropy,
+                  .maxAnisotropy    = m_settings.max_anisotropy,
+                  .compareEnable    = m_settings.compare_enable,
+                  .compareOp        = core::narrow<vk::CompareOp>(m_settings.compare_operation),
+                  .minLod           = m_settings.min_lod,
+                  .maxLod           = m_settings.max_lod,
+                  .borderColor      = core::narrow<vk::BorderColor>(m_settings.border_color),
+                  .unnormalizedCoordinates = m_settings.unnormalized_coordinates })
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
 
@@ -304,20 +303,18 @@ namespace stormkit::gpu {
                 .setBaseArrayLayer(m_subresource_range.base_array_layer)
                 .setLayerCount(m_subresource_range.layer_count);
 
-        const auto components = vk::ComponentMapping {}
-                                    .setR(vk::ComponentSwizzle::eR)
-                                    .setG(vk::ComponentSwizzle::eG)
-                                    .setB(vk::ComponentSwizzle::eB)
-                                    .setA(vk::ComponentSwizzle::eA);
-
-        const auto create_info = vk::ImageViewCreateInfo {}
-                                     .setImage(*this->image().vkHandle())
-                                     .setViewType(core::narrow<vk::ImageViewType>(m_type))
-                                     .setFormat(core::narrow<vk::Format>(this->image().format()))
-                                     .setComponents(components)
-                                     .setSubresourceRange(vk_subresource_range);
-
-        vkCreate<vk::raii::ImageView>(this->device().vkHandle(), create_info)
+        this->device()
+            .vkHandle()
+            .createImageView({
+                .image            = *this->image().vkHandle(),
+                .viewType         = core::narrow<vk::ImageViewType>(m_type),
+                .format           = core::narrow<vk::Format>(this->image().format()),
+                .components       = { .r = vk::ComponentSwizzle::eR,
+                                      .g = vk::ComponentSwizzle::eG,
+                                      .b = vk::ComponentSwizzle::eB,
+                                      .a = vk::ComponentSwizzle::eA },
+                .subresourceRange = vk_subresource_range,
+            })
             .transform(core::monadic::set(m_vk_image_view))
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
@@ -402,7 +399,9 @@ namespace stormkit::gpu {
                                      .setSharingMode(vk::SharingMode::eExclusive)
                                      .setInitialLayout(vk::ImageLayout::eUndefined);
 
-        vkCreate<vk::raii::Image>(this->device().vkHandle(), create_info)
+        this->device()
+            .vkHandle()
+            .createImage(create_info)
             .transform(core::monadic::set(m_vk_image))
             .transform([this, &info]() noexcept -> VulkanExpected<void> {
                 const auto requirements = m_vk_image->getMemoryRequirements();
@@ -412,12 +411,10 @@ namespace stormkit::gpu {
 
                 auto&& allocator = this->device().vmaAllocator();
 
-                try {
-                    m_vma_allocation = allocator.allocateMemoryUnique(requirements, allocate_info);
-                    allocator.bindImageMemory(*m_vma_allocation, *m_vk_image.get());
-                } catch (const vk::SystemError& err) {
-                    return std::unexpected { core::narrow<vk::Result>(err.code().value()) };
-                }
+                auto&& [error, m_vma_allocation] =
+                    allocator.allocateMemoryUnique(requirements, allocate_info);
+                if (error != vk::Result::eSuccess)
+                    return std::unexpected { core::narrow<vk::Result>(error) };
                 return {};
             })
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
@@ -425,10 +422,10 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE Image::Image(const Device&              device,
-                                       const core::math::ExtentU& extent,
-                                       gpu::PixelFormat           format,
-                                       [[maybe_unused]] vk::Image&&                image,
+    STORMKIT_FORCE_INLINE Image::Image(const Device&                device,
+                                       const core::math::ExtentU&   extent,
+                                       gpu::PixelFormat             format,
+                                       [[maybe_unused]] vk::Image&& image,
                                        Tag)
         : Image { device, CreateInfo { extent, format, 1u, 1u }, Tag {} } {
         // m_vk_image  = std::move(image);
diff --git a/modules/stormkit/Gpu/Resource/Shader.mpp b/modules/stormkit/Gpu/Resource/Shader.mpp
index 272d38d6..383f7d89 100644
--- a/modules/stormkit/Gpu/Resource/Shader.mpp
+++ b/modules/stormkit/Gpu/Resource/Shader.mpp
@@ -10,7 +10,6 @@ export module stormkit.Gpu:Resource.Shader;
 
 import std;
 
-
 import stormkit.Core;
 
 import :Core;
@@ -24,7 +23,7 @@ namespace stormkit::gpu {
       public:
         static constexpr auto DEBUG_TYPE = DebugObjectType::Shader_Module;
 
-        Shader(const Device               & device,
+        Shader(const Device&                device,
                const std::filesystem::path& filepath,
                ShaderStageFlag              type,
                Tag);
@@ -38,25 +37,25 @@ namespace stormkit::gpu {
         Shader(Shader&&) noexcept;
         auto operator=(Shader&&) noexcept -> Shader&;
 
-        [[nodiscard]] static auto loadFromFile(const Device               & device,
+        [[nodiscard]] static auto loadFromFile(const Device&                device,
                                                const std::filesystem::path& filepath,
                                                ShaderStageFlag type) noexcept -> Expected<Shader>;
-        [[nodiscard]] static auto fromBytes(const Device              & device,
+        [[nodiscard]] static auto fromBytes(const Device&               device,
                                             std::span<const core::Byte> data,
                                             ShaderStageFlag type) noexcept -> Expected<Shader>;
-        [[nodiscard]] static auto fromSpirvIDs(const Device           & device,
+        [[nodiscard]] static auto fromSpirvIDs(const Device&            device,
                                                std::span<const SpirvID> data,
                                                ShaderStageFlag type) noexcept -> Expected<Shader>;
 
-        [[nodiscard]] static auto allocateAndLoadFromFile(const Device               & device,
+        [[nodiscard]] static auto allocateAndLoadFromFile(const Device&                device,
                                                           const std::filesystem::path& filepath,
                                                           ShaderStageFlag type) noexcept
             -> Expected<std::unique_ptr<Shader>>;
-        [[nodiscard]] static auto allocateFromBytes(const Device              & device,
+        [[nodiscard]] static auto
+                                  allocateFromBytes(const Device&               device,
                                                     std::span<const core::Byte> data,
-                                                    ShaderStageFlag             type) noexcept
-            -> Expected<std::unique_ptr<Shader>>;
-        [[nodiscard]] static auto allocateFromSpirvIDs(const Device           & device,
+                                                    ShaderStageFlag type) noexcept -> Expected<std::unique_ptr<Shader>>;
+        [[nodiscard]] static auto allocateFromSpirvIDs(const Device&            device,
                                                        std::span<const SpirvID> data,
                                                        ShaderStageFlag          type) noexcept
             -> Expected<std::unique_ptr<Shader>>;
@@ -86,7 +85,7 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE
-    Shader::Shader(const Device               & device,
+    Shader::Shader(const Device&                device,
                    const std::filesystem::path& filepath,
                    ShaderStageFlag              type,
                    Tag)
@@ -104,7 +103,7 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     STORMKIT_FORCE_INLINE
-    Shader::Shader(const Device              & device,
+    Shader::Shader(const Device&               device,
                    std::span<const core::Byte> data,
                    ShaderStageFlag             type,
                    Tag)
@@ -136,44 +135,43 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Shader::loadFromFile(const Device               & device,
-                                                    const std::filesystem::path& filepath,
-                                                    ShaderStageFlag              type) noexcept
-        -> Expected<Shader> try {
+    STORMKIT_FORCE_INLINE auto
+        Shader::loadFromFile(const Device&                device,
+                             const std::filesystem::path& filepath,
+                             ShaderStageFlag              type) noexcept -> Expected<Shader> try {
         return Shader { device, std::move(filepath), type, Tag {} };
     } catch (const Result& result) { return std::unexpected(result); }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Shader::fromBytes(const Device              & device,
-                                                 std::span<const core::Byte> data,
-                                                 ShaderStageFlag             type) noexcept
-        -> Expected<Shader> try {
+    STORMKIT_FORCE_INLINE auto
+        Shader::fromBytes(const Device&               device,
+                          std::span<const core::Byte> data,
+                          ShaderStageFlag             type) noexcept -> Expected<Shader> try {
         return Shader { device, data, type, Tag {} };
     } catch (const Result& result) { return std::unexpected(result); }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Shader::fromSpirvIDs(const Device           & device,
-                                                    std::span<const SpirvID> data,
-                                                    ShaderStageFlag          type) noexcept
-        -> Expected<Shader> try {
+    STORMKIT_FORCE_INLINE auto
+        Shader::fromSpirvIDs(const Device&            device,
+                             std::span<const SpirvID> data,
+                             ShaderStageFlag          type) noexcept -> Expected<Shader> try {
         return Shader { device, data, type, Tag {} };
     } catch (const Result& result) { return std::unexpected(result); }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto
-        Shader::allocateAndLoadFromFile(const Device               & device,
-                                        const std::filesystem::path& filepath,
-                                        ShaderStageFlag              type) noexcept
-        -> Expected<std::unique_ptr<Shader>> try {
+    STORMKIT_FORCE_INLINE auto Shader::allocateAndLoadFromFile(
+        const Device&                device,
+        const std::filesystem::path& filepath,
+        ShaderStageFlag              type) noexcept -> Expected<std::unique_ptr<Shader>> try {
         return std::make_unique<Shader>(device, filepath, type, Tag {});
     } catch (const Result& result) { return std::unexpected(result); }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Shader::allocateFromBytes(const Device              & device,
+    STORMKIT_FORCE_INLINE auto Shader::allocateFromBytes(const Device&               device,
                                                          std::span<const core::Byte> data,
                                                          ShaderStageFlag             type) noexcept
         -> Expected<std::unique_ptr<Shader>> try {
@@ -182,7 +180,7 @@ namespace stormkit::gpu {
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE auto Shader::allocateFromSpirvIDs(const Device           & device,
+    STORMKIT_FORCE_INLINE auto Shader::allocateFromSpirvIDs(const Device&            device,
                                                             std::span<const SpirvID> data,
                                                             ShaderStageFlag          type) noexcept
         -> Expected<std::unique_ptr<Shader>> try {
@@ -194,7 +192,9 @@ namespace stormkit::gpu {
     STORMKIT_FORCE_INLINE auto Shader::compile() -> void {
         const auto create_info = vk::ShaderModuleCreateInfo {}.setCode(m_source);
 
-        vkCreate<vk::raii::ShaderModule>(this->device().vkHandle(), create_info)
+        this->device()
+            .vkHandle()
+            .createShaderModule(create_info)
             .transform(core::monadic::set(m_vk_shader_module))
             .transform_error(core::monadic::map(core::monadic::as<Result>(), core::throwError()));
     }
diff --git a/modules/stormkit/Gpu/Vulkan/Utils.mpp b/modules/stormkit/Gpu/Vulkan/Utils.mpp
index 90269040..520d9bd8 100644
--- a/modules/stormkit/Gpu/Vulkan/Utils.mpp
+++ b/modules/stormkit/Gpu/Vulkan/Utils.mpp
@@ -15,7 +15,6 @@ import stormkit.Log;
 
 import vulkan_hpp;
 
-
 export namespace stormkit::gpu {
     template<std::integral T>
     constexpr auto vkMakeVersion(T major, T minor, T patch) noexcept -> core::UInt32;
@@ -39,17 +38,16 @@ export namespace stormkit::gpu {
     template<typename T>
     using VulkanExpected = std::expected<T, vk::Result>;
 
-    template<typename T, typename... Args>
-    auto vkCreate(Args&&...args) noexcept -> VulkanExpected<T>;
-
     template<typename T, typename Func, typename... Args>
-        requires(not core::Is<std::invoke_result_t<Func, T *, Args...>, void>)
-    auto vkCall(T& value, Func&& func_ref, Args&&...args) noexcept
-        -> VulkanExpected<std::invoke_result_t<Func, T *, Args...>>;
+        requires(core::Is<std::invoke_result_t<Func, T *, Args...>, vk::Result>)
+    auto vkCall(T& object, Func&& func, Args&&...args) noexcept -> VulkanExpected<vk::Result>;
 
     template<typename T, typename Func, typename... Args>
-        requires(core::Is<std::invoke_result_t<Func, T *, Args...>, void>)
-    auto vkCall(T& object, Func&& func, Args&&...args) noexcept -> VulkanExpected<void>;
+        requires(core::Is<std::invoke_result_t<Func, T *, Args...>, vk::Result>)
+    auto vkCall(T&                          object,
+                Func&&                      func,
+                std::span<const vk::Result> possible_results,
+                Args&&...args) noexcept -> VulkanExpected<vk::Result>;
 
     auto toRaiiVkHandle() noexcept -> decltype(auto);
     auto toVkHandle() noexcept -> decltype(auto);
@@ -64,29 +62,29 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     template<std::integral T>
-    STORMKIT_FORCE_INLINE constexpr auto vkMakeVersion(T major, T minor, T patch) noexcept
-        -> core::UInt32 {
+    STORMKIT_FORCE_INLINE constexpr auto
+        vkMakeVersion(T major, T minor, T patch) noexcept -> core::UInt32 {
         return vkVersionMajor(major) | vkVersionMinor(minor) | vkVersionPatch(patch);
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE constexpr auto vkVersionMajor(std::integral auto version) noexcept
-        -> core::UInt32 {
+    STORMKIT_FORCE_INLINE constexpr auto
+        vkVersionMajor(std::integral auto version) noexcept -> core::UInt32 {
         return core::as<core::UInt32>(version >> 22u);
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE constexpr auto vkVersionMinor(std::integral auto version) noexcept
-        -> core::UInt32 {
+    STORMKIT_FORCE_INLINE constexpr auto
+        vkVersionMinor(std::integral auto version) noexcept -> core::UInt32 {
         return core::as<core::UInt32>((version >> 12u) & 0x3ffu);
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
-    STORMKIT_FORCE_INLINE constexpr auto vkVersionPatch(std::integral auto version) noexcept
-        -> core::UInt32 {
+    STORMKIT_FORCE_INLINE constexpr auto
+        vkVersionPatch(std::integral auto version) noexcept -> core::UInt32 {
         return core::as<core::UInt32>(version & 0xfffu);
     }
 
@@ -100,43 +98,38 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     template<IsVulkanFlagsType T>
-    STORMKIT_FORCE_INLINE constexpr auto checkFlag(vk::Flags<T> value, vk::Flags<T> flag) noexcept
-        -> bool {
+    STORMKIT_FORCE_INLINE constexpr auto checkFlag(vk::Flags<T> value,
+                                                   vk::Flags<T> flag) noexcept -> bool {
         return (value & flag) == flag;
     }
 
-    /////////////////////////////////////
-    /////////////////////////////////////
-    template<typename T, typename... Args>
-    STORMKIT_FORCE_INLINE auto vkCreate(Args&&...args) noexcept -> VulkanExpected<T> try {
-        return T { std::forward<Args>(args)... };
-    } catch (const vk::SystemError& err) {
-        return std::unexpected { core::narrow<vk::Result>(err.code().value()) };
-    }
-
     /////////////////////////////////////
     /////////////////////////////////////
     template<typename T, typename Func, typename... Args>
-        requires(not core::Is<std::invoke_result_t<Func, T *, Args...>, void>)
-    STORMKIT_FORCE_INLINE auto vkCall(T& value, Func&& func_ref, Args&&...args) noexcept
-        -> VulkanExpected<std::invoke_result_t<Func, T *, Args...>> try {
-        auto func = std::mem_fn(std::forward<Func>(func_ref));
-        return func(value, std::forward<Args>(args)...);
-    } catch (const vk::SystemError& err) {
-        return std::unexpected { core::narrow<vk::Result>(err.code().value()) };
+        requires(core::Is<std::invoke_result_t<Func, T *, Args...>, vk::Result>)
+    STORMKIT_FORCE_INLINE auto
+        vkCall(T& value, Func&& func_ref, Args&&...args) noexcept -> VulkanExpected<vk::Result> {
+        return vkCall<T, Func, Args...>(value,
+                                        std::forward<Func>(func_ref),
+                                        { vk::Result::eSuccess },
+                                        std::forward<Args>(args)...);
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
     template<typename T, typename Func, typename... Args>
-        requires(core::Is<std::invoke_result_t<Func, T *, Args...>, void>)
-    STORMKIT_FORCE_INLINE auto vkCall(T& value, Func&& func_ref, Args&&...args) noexcept
-        -> VulkanExpected<void> try {
+        requires(core::Is<std::invoke_result_t<Func, T *, Args...>, vk::Result>)
+    STORMKIT_FORCE_INLINE auto vkCall(T&                          value,
+                                      Func&&                      func_ref,
+                                      std::span<const vk::Result> possible_results,
+                                      Args&&...args) noexcept -> VulkanExpected<vk::Result> {
         auto func = std::mem_fn(std::forward<Func>(func_ref));
-        func(value, std::forward<Args>(args)...);
-        return {};
-    } catch (const vk::SystemError& err) {
-        return std::unexpected { core::narrow<vk::Result>(err.code().value()) };
+
+        const auto result = func(value, std::forward<Args>(args)...);
+        if (std::ranges::any_of(possible_results, core::toUnary(core::monadic::isEqual(), result)))
+            return result;
+
+        return std::unexpected { result };
     }
 
     /////////////////////////////////////
diff --git a/modules/stormkit/Gpu/Vulkan/vma.mpp b/modules/stormkit/Gpu/Vulkan/vma.mpp
index 4c304b61..00551754 100644
--- a/modules/stormkit/Gpu/Vulkan/vma.mpp
+++ b/modules/stormkit/Gpu/Vulkan/vma.mpp
@@ -1,69 +1,14 @@
 module;
 
-#define VMA_IMPLEMENTATION
 #include <vk_mem_alloc.hpp>
 
 export module vma;
 
-export namespace VMA_HPP_NAMESPACE {
-    using VMA_HPP_NAMESPACE::operator|;
-    using VMA_HPP_NAMESPACE::operator&;
-    using VMA_HPP_NAMESPACE::operator^;
-    using VMA_HPP_NAMESPACE::operator~;
-    using VMA_HPP_NAMESPACE::Allocation;
-    using VMA_HPP_NAMESPACE::AllocationCreateFlagBits;
-    using VMA_HPP_NAMESPACE::AllocationCreateFlags;
-    using VMA_HPP_NAMESPACE::AllocationCreateInfo;
-    using VMA_HPP_NAMESPACE::AllocationInfo;
-    using VMA_HPP_NAMESPACE::Allocator;
-    using VMA_HPP_NAMESPACE::AllocatorCreateFlagBits;
-    using VMA_HPP_NAMESPACE::AllocatorCreateFlags;
-    using VMA_HPP_NAMESPACE::AllocatorCreateInfo;
-    using VMA_HPP_NAMESPACE::AllocatorInfo;
-    using VMA_HPP_NAMESPACE::Budget;
-    using VMA_HPP_NAMESPACE::createAllocator;
-    using VMA_HPP_NAMESPACE::createVirtualBlock;
-    using VMA_HPP_NAMESPACE::DefragmentationContext;
-    using VMA_HPP_NAMESPACE::DefragmentationFlagBits;
-    using VMA_HPP_NAMESPACE::DefragmentationFlags;
-    using VMA_HPP_NAMESPACE::DefragmentationInfo;
-    using VMA_HPP_NAMESPACE::DefragmentationMove;
-    using VMA_HPP_NAMESPACE::DefragmentationMoveOperation;
-    using VMA_HPP_NAMESPACE::DefragmentationPassMoveInfo;
-    using VMA_HPP_NAMESPACE::DefragmentationStats;
-    using VMA_HPP_NAMESPACE::DetailedStatistics;
-    using VMA_HPP_NAMESPACE::DeviceMemoryCallbacks;
-    using VMA_HPP_NAMESPACE::functionsFromDispatcher;
-    using VMA_HPP_NAMESPACE::MemoryUsage;
-    using VMA_HPP_NAMESPACE::Pool;
-    using VMA_HPP_NAMESPACE::PoolCreateFlagBits;
-    using VMA_HPP_NAMESPACE::PoolCreateFlags;
-    using VMA_HPP_NAMESPACE::PoolCreateInfo;
-    using VMA_HPP_NAMESPACE::Statistics;
-    using VMA_HPP_NAMESPACE::to_string;
-    using VMA_HPP_NAMESPACE::TotalStatistics;
-    using VMA_HPP_NAMESPACE::VirtualAllocation;
-    using VMA_HPP_NAMESPACE::VirtualAllocationCreateFlagBits;
-    using VMA_HPP_NAMESPACE::VirtualAllocationCreateFlags;
-    using VMA_HPP_NAMESPACE::VirtualAllocationCreateInfo;
-    using VMA_HPP_NAMESPACE::VirtualAllocationInfo;
-    using VMA_HPP_NAMESPACE::VirtualBlock;
-    using VMA_HPP_NAMESPACE::VirtualBlockCreateFlagBits;
-    using VMA_HPP_NAMESPACE::VirtualBlockCreateFlags;
-    using VMA_HPP_NAMESPACE::VirtualBlockCreateInfo;
-    using VMA_HPP_NAMESPACE::VulkanFunctions;
-} // namespace VMA_HPP_NAMESPACE
+export import vk_mem_alloc_hpp;
 
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
 export namespace VMA_HPP_NAMESPACE {
-    using VMA_HPP_NAMESPACE::UniqueAllocation;
-    using VMA_HPP_NAMESPACE::UniqueAllocator;
     using VMA_HPP_NAMESPACE::createAllocatorUnique;
-    using VMA_HPP_NAMESPACE::UniqueBuffer;
-    using VMA_HPP_NAMESPACE::UniqueImage;
-    using VMA_HPP_NAMESPACE::UniquePool;
-    using VMA_HPP_NAMESPACE::UniqueVirtualAllocation;
-    using VMA_HPP_NAMESPACE::UniqueVirtualBlock;
 
     namespace raii {
         using Pool              = VMA_HPP_NAMESPACE::UniquePool;
@@ -77,18 +22,3 @@ export namespace VMA_HPP_NAMESPACE {
 } // namespace VMA_HPP_NAMESPACE
 #endif
 
-module : private;
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-// Instantiate unique handle templates.
-// This is a workaround for MSVC bugs, but wouldn't harm on other compilers anyway.
-namespace VULKAN_HPP_NAMESPACE {
-  template class UniqueHandle<Buffer, VMA_HPP_NAMESPACE::Dispatcher>;
-  template class UniqueHandle<Image, VMA_HPP_NAMESPACE::Dispatcher>;
-  template class UniqueHandle<VMA_HPP_NAMESPACE::Allocator, VMA_HPP_NAMESPACE::Dispatcher>;
-  template class UniqueHandle<VMA_HPP_NAMESPACE::Pool, VMA_HPP_NAMESPACE::Dispatcher>;
-  template class UniqueHandle<VMA_HPP_NAMESPACE::Allocation, VMA_HPP_NAMESPACE::Dispatcher>;
-  template class UniqueHandle<VMA_HPP_NAMESPACE::VirtualAllocation, VMA_HPP_NAMESPACE::Dispatcher>;
-  template class UniqueHandle<VMA_HPP_NAMESPACE::VirtualBlock, VMA_HPP_NAMESPACE::Dispatcher>;
-}
-#endif
diff --git a/modules/stormkit/Gpu/Vulkan/vulkan.mpp b/modules/stormkit/Gpu/Vulkan/vulkan.mpp
deleted file mode 100644
index bafe8702..00000000
--- a/modules/stormkit/Gpu/Vulkan/vulkan.mpp
+++ /dev/null
@@ -1,3196 +0,0 @@
-// Copyright 2015-2023 The Khronos Group Inc.
-//
-// SPDX-License-Identifier: Apache-2.0 OR MIT
-//
-
-// This header is generated from the Khronos Vulkan XML API Registry.
-
-// Note: This module is still in an experimental state.
-// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
-
-module;
-
-#include <vulkan/vulkan.hpp>
-#include <vulkan/vulkan_extension_inspection.hpp>
-#include <vulkan/vulkan_format_traits.hpp>
-#include <vulkan/vulkan_hash.hpp>
-#include <vulkan/vulkan_raii.hpp>
-#include <vulkan/vulkan_shared.hpp>
-
-export module vulkan_hpp;
-
-export namespace VULKAN_HPP_NAMESPACE
-{
-  //=====================================
-  //=== HARDCODED TYPEs AND FUNCTIONs ===
-  //=====================================
-  using VULKAN_HPP_NAMESPACE::ArrayWrapper1D;
-  using VULKAN_HPP_NAMESPACE::ArrayWrapper2D;
-  using VULKAN_HPP_NAMESPACE::DispatchLoaderBase;
-  using VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic;
-  using VULKAN_HPP_NAMESPACE::Flags;
-  using VULKAN_HPP_NAMESPACE::FlagTraits;
-
-#if !defined( VK_NO_PROTOTYPES )
-  using VULKAN_HPP_NAMESPACE::DispatchLoaderStatic;
-#endif /*VK_NO_PROTOTYPES*/
-
-  using VULKAN_HPP_NAMESPACE::operator&;
-  using VULKAN_HPP_NAMESPACE::operator|;
-  using VULKAN_HPP_NAMESPACE::operator^;
-  using VULKAN_HPP_NAMESPACE::operator~;
-  using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE;
-
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-  using VULKAN_HPP_NAMESPACE::ArrayProxy;
-  using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries;
-  using VULKAN_HPP_NAMESPACE::Optional;
-  using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
-  using VULKAN_HPP_NAMESPACE::StructureChain;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-  using VULKAN_HPP_NAMESPACE::ObjectDestroy;
-  using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
-  using VULKAN_HPP_NAMESPACE::ObjectFree;
-  using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
-  using VULKAN_HPP_NAMESPACE::ObjectRelease;
-  using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
-  using VULKAN_HPP_NAMESPACE::PoolFree;
-  using VULKAN_HPP_NAMESPACE::PoolFreeShared;
-  using VULKAN_HPP_NAMESPACE::SharedHandle;
-  using VULKAN_HPP_NAMESPACE::UniqueHandle;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  //==================
-  //=== BASE TYPEs ===
-  //==================
-  using VULKAN_HPP_NAMESPACE::Bool32;
-  using VULKAN_HPP_NAMESPACE::DeviceAddress;
-  using VULKAN_HPP_NAMESPACE::DeviceSize;
-  using VULKAN_HPP_NAMESPACE::RemoteAddressNV;
-  using VULKAN_HPP_NAMESPACE::SampleMask;
-
-  //=============
-  //=== ENUMs ===
-  //=============
-  using VULKAN_HPP_NAMESPACE::CppType;
-
-  //=== VK_VERSION_1_0 ===
-  using VULKAN_HPP_NAMESPACE::AccessFlagBits;
-  using VULKAN_HPP_NAMESPACE::AccessFlags;
-  using VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlagBits;
-  using VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags;
-  using VULKAN_HPP_NAMESPACE::AttachmentLoadOp;
-  using VULKAN_HPP_NAMESPACE::AttachmentStoreOp;
-  using VULKAN_HPP_NAMESPACE::BlendFactor;
-  using VULKAN_HPP_NAMESPACE::BlendOp;
-  using VULKAN_HPP_NAMESPACE::BorderColor;
-  using VULKAN_HPP_NAMESPACE::BufferCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::BufferCreateFlags;
-  using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits;
-  using VULKAN_HPP_NAMESPACE::BufferUsageFlags;
-  using VULKAN_HPP_NAMESPACE::BufferViewCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::BufferViewCreateFlags;
-  using VULKAN_HPP_NAMESPACE::ColorComponentFlagBits;
-  using VULKAN_HPP_NAMESPACE::ColorComponentFlags;
-  using VULKAN_HPP_NAMESPACE::CommandBufferLevel;
-  using VULKAN_HPP_NAMESPACE::CommandBufferResetFlagBits;
-  using VULKAN_HPP_NAMESPACE::CommandBufferResetFlags;
-  using VULKAN_HPP_NAMESPACE::CommandBufferUsageFlagBits;
-  using VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags;
-  using VULKAN_HPP_NAMESPACE::CommandPoolCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags;
-  using VULKAN_HPP_NAMESPACE::CommandPoolResetFlagBits;
-  using VULKAN_HPP_NAMESPACE::CommandPoolResetFlags;
-  using VULKAN_HPP_NAMESPACE::CompareOp;
-  using VULKAN_HPP_NAMESPACE::ComponentSwizzle;
-  using VULKAN_HPP_NAMESPACE::CullModeFlagBits;
-  using VULKAN_HPP_NAMESPACE::CullModeFlags;
-  using VULKAN_HPP_NAMESPACE::DependencyFlagBits;
-  using VULKAN_HPP_NAMESPACE::DependencyFlags;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlagBits;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags;
-  using VULKAN_HPP_NAMESPACE::DescriptorType;
-  using VULKAN_HPP_NAMESPACE::DeviceCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::DeviceCreateFlags;
-  using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
-  using VULKAN_HPP_NAMESPACE::DynamicState;
-  using VULKAN_HPP_NAMESPACE::EventCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::EventCreateFlags;
-  using VULKAN_HPP_NAMESPACE::FenceCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::FenceCreateFlags;
-  using VULKAN_HPP_NAMESPACE::Filter;
-  using VULKAN_HPP_NAMESPACE::Format;
-  using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits;
-  using VULKAN_HPP_NAMESPACE::FormatFeatureFlags;
-  using VULKAN_HPP_NAMESPACE::FramebufferCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::FramebufferCreateFlags;
-  using VULKAN_HPP_NAMESPACE::FrontFace;
-  using VULKAN_HPP_NAMESPACE::ImageAspectFlagBits;
-  using VULKAN_HPP_NAMESPACE::ImageAspectFlags;
-  using VULKAN_HPP_NAMESPACE::ImageCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::ImageCreateFlags;
-  using VULKAN_HPP_NAMESPACE::ImageLayout;
-  using VULKAN_HPP_NAMESPACE::ImageTiling;
-  using VULKAN_HPP_NAMESPACE::ImageType;
-  using VULKAN_HPP_NAMESPACE::ImageUsageFlagBits;
-  using VULKAN_HPP_NAMESPACE::ImageUsageFlags;
-  using VULKAN_HPP_NAMESPACE::ImageViewCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::ImageViewCreateFlags;
-  using VULKAN_HPP_NAMESPACE::ImageViewType;
-  using VULKAN_HPP_NAMESPACE::IndexType;
-  using VULKAN_HPP_NAMESPACE::InstanceCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::InstanceCreateFlags;
-  using VULKAN_HPP_NAMESPACE::InternalAllocationType;
-  using VULKAN_HPP_NAMESPACE::LogicOp;
-  using VULKAN_HPP_NAMESPACE::MemoryHeapFlagBits;
-  using VULKAN_HPP_NAMESPACE::MemoryHeapFlags;
-  using VULKAN_HPP_NAMESPACE::MemoryMapFlagBits;
-  using VULKAN_HPP_NAMESPACE::MemoryMapFlags;
-  using VULKAN_HPP_NAMESPACE::MemoryPropertyFlagBits;
-  using VULKAN_HPP_NAMESPACE::MemoryPropertyFlags;
-  using VULKAN_HPP_NAMESPACE::ObjectType;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceType;
-  using VULKAN_HPP_NAMESPACE::PipelineBindPoint;
-  using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion;
-  using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineStageFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::PolygonMode;
-  using VULKAN_HPP_NAMESPACE::PrimitiveTopology;
-  using VULKAN_HPP_NAMESPACE::QueryControlFlagBits;
-  using VULKAN_HPP_NAMESPACE::QueryControlFlags;
-  using VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlagBits;
-  using VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags;
-  using VULKAN_HPP_NAMESPACE::QueryPoolCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags;
-  using VULKAN_HPP_NAMESPACE::QueryResultFlagBits;
-  using VULKAN_HPP_NAMESPACE::QueryResultFlags;
-  using VULKAN_HPP_NAMESPACE::QueryType;
-  using VULKAN_HPP_NAMESPACE::QueueFlagBits;
-  using VULKAN_HPP_NAMESPACE::QueueFlags;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreateFlags;
-  using VULKAN_HPP_NAMESPACE::Result;
-  using VULKAN_HPP_NAMESPACE::SampleCountFlagBits;
-  using VULKAN_HPP_NAMESPACE::SampleCountFlags;
-  using VULKAN_HPP_NAMESPACE::SamplerAddressMode;
-  using VULKAN_HPP_NAMESPACE::SamplerCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::SamplerCreateFlags;
-  using VULKAN_HPP_NAMESPACE::SamplerMipmapMode;
-  using VULKAN_HPP_NAMESPACE::SemaphoreCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags;
-  using VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags;
-  using VULKAN_HPP_NAMESPACE::ShaderStageFlagBits;
-  using VULKAN_HPP_NAMESPACE::ShaderStageFlags;
-  using VULKAN_HPP_NAMESPACE::SharingMode;
-  using VULKAN_HPP_NAMESPACE::SparseImageFormatFlagBits;
-  using VULKAN_HPP_NAMESPACE::SparseImageFormatFlags;
-  using VULKAN_HPP_NAMESPACE::SparseMemoryBindFlagBits;
-  using VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags;
-  using VULKAN_HPP_NAMESPACE::StencilFaceFlagBits;
-  using VULKAN_HPP_NAMESPACE::StencilFaceFlags;
-  using VULKAN_HPP_NAMESPACE::StencilOp;
-  using VULKAN_HPP_NAMESPACE::StructureType;
-  using VULKAN_HPP_NAMESPACE::SubpassContents;
-  using VULKAN_HPP_NAMESPACE::SubpassDescriptionFlagBits;
-  using VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags;
-  using VULKAN_HPP_NAMESPACE::SystemAllocationScope;
-  using VULKAN_HPP_NAMESPACE::VendorId;
-  using VULKAN_HPP_NAMESPACE::VertexInputRate;
-
-  //=== VK_VERSION_1_1 ===
-  using VULKAN_HPP_NAMESPACE::ChromaLocation;
-  using VULKAN_HPP_NAMESPACE::ChromaLocationKHR;
-  using VULKAN_HPP_NAMESPACE::CommandPoolTrimFlagBits;
-  using VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateTypeKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits;
-  using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags;
-  using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits;
-  using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBits;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBits;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags;
-  using VULKAN_HPP_NAMESPACE::FenceImportFlagBits;
-  using VULKAN_HPP_NAMESPACE::FenceImportFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::FenceImportFlags;
-  using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBits;
-  using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryAllocateFlags;
-  using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBits;
-  using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags;
-  using VULKAN_HPP_NAMESPACE::PointClippingBehavior;
-  using VULKAN_HPP_NAMESPACE::PointClippingBehaviorKHR;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversionKHR;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrRange;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrRangeKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreImportFlagBits;
-  using VULKAN_HPP_NAMESPACE::SemaphoreImportFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreImportFlags;
-  using VULKAN_HPP_NAMESPACE::SubgroupFeatureFlagBits;
-  using VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags;
-  using VULKAN_HPP_NAMESPACE::TessellationDomainOrigin;
-  using VULKAN_HPP_NAMESPACE::TessellationDomainOriginKHR;
-
-  //=== VK_VERSION_1_2 ===
-  using VULKAN_HPP_NAMESPACE::DescriptorBindingFlagBits;
-  using VULKAN_HPP_NAMESPACE::DescriptorBindingFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorBindingFlags;
-  using VULKAN_HPP_NAMESPACE::DriverId;
-  using VULKAN_HPP_NAMESPACE::DriverIdKHR;
-  using VULKAN_HPP_NAMESPACE::ResolveModeFlagBits;
-  using VULKAN_HPP_NAMESPACE::ResolveModeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::ResolveModeFlags;
-  using VULKAN_HPP_NAMESPACE::SamplerReductionMode;
-  using VULKAN_HPP_NAMESPACE::SamplerReductionModeEXT;
-  using VULKAN_HPP_NAMESPACE::SemaphoreType;
-  using VULKAN_HPP_NAMESPACE::SemaphoreTypeKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlagBits;
-  using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags;
-  using VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence;
-  using VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependenceKHR;
-
-  //=== VK_VERSION_1_3 ===
-  using VULKAN_HPP_NAMESPACE::AccessFlagBits2;
-  using VULKAN_HPP_NAMESPACE::AccessFlagBits2KHR;
-  using VULKAN_HPP_NAMESPACE::AccessFlags2;
-  using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2;
-  using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2KHR;
-  using VULKAN_HPP_NAMESPACE::FormatFeatureFlags2;
-  using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBits;
-  using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlags;
-  using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2;
-  using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2KHR;
-  using VULKAN_HPP_NAMESPACE::PipelineStageFlags2;
-  using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBits;
-  using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlags;
-  using VULKAN_HPP_NAMESPACE::RenderingFlagBits;
-  using VULKAN_HPP_NAMESPACE::RenderingFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::RenderingFlags;
-  using VULKAN_HPP_NAMESPACE::SubmitFlagBits;
-  using VULKAN_HPP_NAMESPACE::SubmitFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::SubmitFlags;
-  using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBits;
-  using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::ToolPurposeFlags;
-
-  //=== VK_KHR_surface ===
-  using VULKAN_HPP_NAMESPACE::ColorSpaceKHR;
-  using VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::PresentModeKHR;
-  using VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR;
-
-  //=== VK_KHR_swapchain ===
-  using VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::SwapchainCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR;
-
-  //=== VK_KHR_display ===
-  using VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR;
-
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-  //=== VK_KHR_xlib_surface ===
-  using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR;
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-  //=== VK_KHR_xcb_surface ===
-  using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR;
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-  //=== VK_KHR_wayland_surface ===
-  using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR;
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-  //=== VK_KHR_android_surface ===
-  using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_KHR_win32_surface ===
-  using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_EXT_debug_report ===
-  using VULKAN_HPP_NAMESPACE::DebugReportFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT;
-
-  //=== VK_AMD_rasterization_order ===
-  using VULKAN_HPP_NAMESPACE::RasterizationOrderAMD;
-
-  //=== VK_KHR_video_queue ===
-  using VULKAN_HPP_NAMESPACE::QueryResultStatusKHR;
-  using VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCapabilityFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCodingControlFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEndCodingFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateFlagsKHR;
-
-  //=== VK_KHR_video_decode_queue ===
-  using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilityFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilityFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagsKHR;
-
-  //=== VK_EXT_transform_feedback ===
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_EXT_video_encode_h264 ===
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_EXT_video_encode_h265 ===
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_KHR_video_decode_h264 ===
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsKHR;
-
-  //=== VK_AMD_shader_info ===
-  using VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD;
-
-#if defined( VK_USE_PLATFORM_GGP )
-  //=== VK_GGP_stream_descriptor_surface ===
-  using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagBitsGGP;
-  using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP;
-#endif /*VK_USE_PLATFORM_GGP*/
-
-  //=== VK_NV_external_memory_capabilities ===
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV;
-
-  //=== VK_EXT_validation_flags ===
-  using VULKAN_HPP_NAMESPACE::ValidationCheckEXT;
-
-#if defined( VK_USE_PLATFORM_VI_NN )
-  //=== VK_NN_vi_surface ===
-  using VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagBitsNN;
-  using VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN;
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-  //=== VK_EXT_pipeline_robustness ===
-  using VULKAN_HPP_NAMESPACE::PipelineRobustnessBufferBehaviorEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRobustnessImageBehaviorEXT;
-
-  //=== VK_EXT_conditional_rendering ===
-  using VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT;
-
-  //=== VK_EXT_display_surface_counter ===
-  using VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT;
-
-  //=== VK_EXT_display_control ===
-  using VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT;
-  using VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT;
-  using VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT;
-
-  //=== VK_NV_viewport_swizzle ===
-  using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV;
-  using VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV;
-
-  //=== VK_EXT_discard_rectangles ===
-  using VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT;
-
-  //=== VK_EXT_conservative_rasterization ===
-  using VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT;
-
-  //=== VK_EXT_depth_clip_enable ===
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT;
-
-  //=== VK_KHR_performance_query ===
-  using VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR;
-
-#if defined( VK_USE_PLATFORM_IOS_MVK )
-  //=== VK_MVK_ios_surface ===
-  using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagBitsMVK;
-  using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK;
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#if defined( VK_USE_PLATFORM_MACOS_MVK )
-  //=== VK_MVK_macos_surface ===
-  using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagBitsMVK;
-  using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK;
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-  //=== VK_EXT_debug_utils ===
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT;
-
-  //=== VK_EXT_blend_operation_advanced ===
-  using VULKAN_HPP_NAMESPACE::BlendOverlapEXT;
-
-  //=== VK_NV_fragment_coverage_to_color ===
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV;
-
-  //=== VK_KHR_acceleration_structure ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV;
-  using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureModeKHR;
-  using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR;
-  using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeNV;
-  using VULKAN_HPP_NAMESPACE::GeometryFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::GeometryFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::GeometryFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::GeometryTypeKHR;
-  using VULKAN_HPP_NAMESPACE::GeometryTypeNV;
-
-  //=== VK_KHR_ray_tracing_pipeline ===
-  using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR;
-  using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeNV;
-  using VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR;
-
-  //=== VK_NV_framebuffer_mixed_samples ===
-  using VULKAN_HPP_NAMESPACE::CoverageModulationModeNV;
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV;
-
-  //=== VK_EXT_validation_cache ===
-  using VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::ValidationCacheHeaderVersionEXT;
-
-  //=== VK_NV_shading_rate_image ===
-  using VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV;
-  using VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV;
-
-  //=== VK_NV_ray_tracing ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV;
-
-  //=== VK_AMD_pipeline_compiler_control ===
-  using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagBitsAMD;
-  using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD;
-
-  //=== VK_EXT_calibrated_timestamps ===
-  using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
-
-  //=== VK_KHR_global_priority ===
-  using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT;
-  using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR;
-
-  //=== VK_AMD_memory_overallocation_behavior ===
-  using VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD;
-
-  //=== VK_INTEL_performance_query ===
-  using VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL;
-  using VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL;
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_imagepipe_surface ===
-  using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagBitsFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-  //=== VK_EXT_metal_surface ===
-  using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT;
-#endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-  //=== VK_KHR_fragment_shading_rate ===
-  using VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR;
-
-  //=== VK_AMD_shader_core_properties2 ===
-  using VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagBitsAMD;
-  using VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD;
-
-  //=== VK_EXT_validation_features ===
-  using VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT;
-  using VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT;
-
-  //=== VK_NV_coverage_reduction_mode ===
-  using VULKAN_HPP_NAMESPACE::CoverageReductionModeNV;
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV;
-
-  //=== VK_EXT_provoking_vertex ===
-  using VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_EXT_full_screen_exclusive ===
-  using VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_EXT_headless_surface ===
-  using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT;
-
-  //=== VK_EXT_line_rasterization ===
-  using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT;
-
-  //=== VK_KHR_pipeline_executable_properties ===
-  using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR;
-
-  //=== VK_EXT_host_image_copy ===
-  using VULKAN_HPP_NAMESPACE::HostImageCopyFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::HostImageCopyFlagsEXT;
-
-  //=== VK_KHR_map_memory2 ===
-  using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR;
-
-  //=== VK_EXT_surface_maintenance1 ===
-  using VULKAN_HPP_NAMESPACE::PresentGravityFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PresentGravityFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::PresentScalingFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::PresentScalingFlagsEXT;
-
-  //=== VK_NV_device_generated_commands ===
-  using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV;
-  using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV;
-  using VULKAN_HPP_NAMESPACE::IndirectStateFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV;
-
-  //=== VK_EXT_depth_bias_control ===
-  using VULKAN_HPP_NAMESPACE::DepthBiasRepresentationEXT;
-
-  //=== VK_EXT_device_memory_report ===
-  using VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_KHR_video_encode_queue ===
-  using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagBitsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagsKHR;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_NV_device_diagnostics_config ===
-  using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV;
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-  //=== VK_EXT_metal_objects ===
-  using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagsEXT;
-#endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-  //=== VK_EXT_graphics_pipeline_library ===
-  using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagsEXT;
-
-  //=== VK_NV_fragment_shading_rate_enums ===
-  using VULKAN_HPP_NAMESPACE::FragmentShadingRateNV;
-  using VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV;
-
-  //=== VK_NV_ray_tracing_motion_blur ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagsNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV;
-
-  //=== VK_EXT_image_compression_control ===
-  using VULKAN_HPP_NAMESPACE::ImageCompressionFixedRateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::ImageCompressionFixedRateFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::ImageCompressionFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::ImageCompressionFlagsEXT;
-
-  //=== VK_EXT_device_fault ===
-  using VULKAN_HPP_NAMESPACE::DeviceFaultAddressTypeEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionEXT;
-
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-  //=== VK_EXT_directfb_surface ===
-  using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT;
-#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-  //=== VK_EXT_device_address_binding_report ===
-  using VULKAN_HPP_NAMESPACE::DeviceAddressBindingFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceAddressBindingFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceAddressBindingTypeEXT;
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_buffer_collection ===
-  using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagBitsFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagBitsFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  //=== VK_EXT_frame_boundary ===
-  using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT;
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-  //=== VK_QNX_screen_surface ===
-  using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagBitsQNX;
-  using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX;
-#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-  //=== VK_EXT_opacity_micromap ===
-  using VULKAN_HPP_NAMESPACE::BuildMicromapFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::BuildMicromapFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::BuildMicromapModeEXT;
-  using VULKAN_HPP_NAMESPACE::CopyMicromapModeEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapCreateFlagsEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapTypeEXT;
-  using VULKAN_HPP_NAMESPACE::OpacityMicromapFormatEXT;
-  using VULKAN_HPP_NAMESPACE::OpacityMicromapSpecialIndexEXT;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_NV_displacement_micromap ===
-  using VULKAN_HPP_NAMESPACE::DisplacementMicromapFormatNV;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_NV_memory_decompression ===
-  using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsNV;
-
-  //=== VK_EXT_subpass_merge_feedback ===
-  using VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT;
-
-  //=== VK_LUNARG_direct_driver_loading ===
-  using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagBitsLUNARG;
-  using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG;
-  using VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG;
-
-  //=== VK_NV_optical_flow ===
-  using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagsNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowGridSizeFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowGridSizeFlagsNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowPerformanceLevelNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateFlagsNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowUsageFlagBitsNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowUsageFlagsNV;
-
-  //=== VK_KHR_maintenance5 ===
-  using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits2KHR;
-  using VULKAN_HPP_NAMESPACE::BufferUsageFlags2KHR;
-  using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits2KHR;
-  using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2KHR;
-
-  //=== VK_EXT_shader_object ===
-  using VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT;
-  using VULKAN_HPP_NAMESPACE::ShaderCreateFlagBitsEXT;
-  using VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT;
-
-  //=== VK_NV_ray_tracing_invocation_reorder ===
-  using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV;
-
-  //=== VK_NV_low_latency2 ===
-  using VULKAN_HPP_NAMESPACE::LatencyMarkerNV;
-  using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV;
-
-  //=== VK_KHR_cooperative_matrix ===
-  using VULKAN_HPP_NAMESPACE::ComponentTypeKHR;
-  using VULKAN_HPP_NAMESPACE::ComponentTypeNV;
-  using VULKAN_HPP_NAMESPACE::ScopeKHR;
-  using VULKAN_HPP_NAMESPACE::ScopeNV;
-
-  //=== VK_QCOM_image_processing2 ===
-  using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM;
-
-  //=== VK_QCOM_filter_cubic_weights ===
-  using VULKAN_HPP_NAMESPACE::CubicFilterWeightsQCOM;
-
-  //=== VK_MSFT_layered_driver ===
-  using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT;
-
-  //=========================
-  //=== Index Type Traits ===
-  //=========================
-  using VULKAN_HPP_NAMESPACE::IndexTypeValue;
-
-  //======================
-  //=== ENUM to_string ===
-  //======================
-#if !defined( VULKAN_HPP_NO_TO_STRING )
-  using VULKAN_HPP_NAMESPACE::to_string;
-  using VULKAN_HPP_NAMESPACE::toHexString;
-#endif /*VULKAN_HPP_NO_TO_STRING*/
-
-  //=============================
-  //=== EXCEPTIONs AND ERRORs ===
-  //=============================
-#if !defined( VULKAN_HPP_NO_EXCEPTIONS )
-  using VULKAN_HPP_NAMESPACE::DeviceLostError;
-  using VULKAN_HPP_NAMESPACE::Error;
-  using VULKAN_HPP_NAMESPACE::errorCategory;
-  using VULKAN_HPP_NAMESPACE::ErrorCategoryImpl;
-  using VULKAN_HPP_NAMESPACE::ExtensionNotPresentError;
-  using VULKAN_HPP_NAMESPACE::FeatureNotPresentError;
-  using VULKAN_HPP_NAMESPACE::FormatNotSupportedError;
-  using VULKAN_HPP_NAMESPACE::FragmentationError;
-  using VULKAN_HPP_NAMESPACE::FragmentedPoolError;
-  using VULKAN_HPP_NAMESPACE::ImageUsageNotSupportedKHRError;
-  using VULKAN_HPP_NAMESPACE::IncompatibleDisplayKHRError;
-  using VULKAN_HPP_NAMESPACE::IncompatibleDriverError;
-  using VULKAN_HPP_NAMESPACE::InitializationFailedError;
-  using VULKAN_HPP_NAMESPACE::InvalidDrmFormatModifierPlaneLayoutEXTError;
-  using VULKAN_HPP_NAMESPACE::InvalidExternalHandleError;
-  using VULKAN_HPP_NAMESPACE::InvalidOpaqueCaptureAddressError;
-  using VULKAN_HPP_NAMESPACE::InvalidShaderNVError;
-  using VULKAN_HPP_NAMESPACE::LayerNotPresentError;
-  using VULKAN_HPP_NAMESPACE::LogicError;
-  using VULKAN_HPP_NAMESPACE::make_error_code;
-  using VULKAN_HPP_NAMESPACE::make_error_condition;
-  using VULKAN_HPP_NAMESPACE::MemoryMapFailedError;
-  using VULKAN_HPP_NAMESPACE::NativeWindowInUseKHRError;
-  using VULKAN_HPP_NAMESPACE::NotPermittedKHRError;
-  using VULKAN_HPP_NAMESPACE::OutOfDateKHRError;
-  using VULKAN_HPP_NAMESPACE::OutOfDeviceMemoryError;
-  using VULKAN_HPP_NAMESPACE::OutOfHostMemoryError;
-  using VULKAN_HPP_NAMESPACE::OutOfPoolMemoryError;
-  using VULKAN_HPP_NAMESPACE::SurfaceLostKHRError;
-  using VULKAN_HPP_NAMESPACE::SystemError;
-  using VULKAN_HPP_NAMESPACE::TooManyObjectsError;
-  using VULKAN_HPP_NAMESPACE::UnknownError;
-  using VULKAN_HPP_NAMESPACE::ValidationFailedEXTError;
-  using VULKAN_HPP_NAMESPACE::VideoPictureLayoutNotSupportedKHRError;
-  using VULKAN_HPP_NAMESPACE::VideoProfileCodecNotSupportedKHRError;
-  using VULKAN_HPP_NAMESPACE::VideoProfileFormatNotSupportedKHRError;
-  using VULKAN_HPP_NAMESPACE::VideoProfileOperationNotSupportedKHRError;
-  using VULKAN_HPP_NAMESPACE::VideoStdVersionNotSupportedKHRError;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-  using VULKAN_HPP_NAMESPACE::FullScreenExclusiveModeLostEXTError;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-  using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError;
-  using VULKAN_HPP_NAMESPACE::IncompatibleShaderBinaryEXTError;
-#endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-  using VULKAN_HPP_NAMESPACE::createResultValueType;
-  using VULKAN_HPP_NAMESPACE::ignore;
-  using VULKAN_HPP_NAMESPACE::resultCheck;
-  using VULKAN_HPP_NAMESPACE::ResultValue;
-  using VULKAN_HPP_NAMESPACE::ResultValueType;
-
-  //===========================
-  //=== CONSTEXPR CONSTANTs ===
-  //===========================
-
-  //=== VK_VERSION_1_0 ===
-  using VULKAN_HPP_NAMESPACE::AttachmentUnused;
-  using VULKAN_HPP_NAMESPACE::False;
-  using VULKAN_HPP_NAMESPACE::LodClampNone;
-  using VULKAN_HPP_NAMESPACE::MaxDescriptionSize;
-  using VULKAN_HPP_NAMESPACE::MaxExtensionNameSize;
-  using VULKAN_HPP_NAMESPACE::MaxMemoryHeaps;
-  using VULKAN_HPP_NAMESPACE::MaxMemoryTypes;
-  using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceNameSize;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyIgnored;
-  using VULKAN_HPP_NAMESPACE::RemainingArrayLayers;
-  using VULKAN_HPP_NAMESPACE::RemainingMipLevels;
-  using VULKAN_HPP_NAMESPACE::SubpassExternal;
-  using VULKAN_HPP_NAMESPACE::True;
-  using VULKAN_HPP_NAMESPACE::UuidSize;
-  using VULKAN_HPP_NAMESPACE::WholeSize;
-
-  //=== VK_VERSION_1_1 ===
-  using VULKAN_HPP_NAMESPACE::LuidSize;
-  using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSize;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyExternal;
-
-  //=== VK_VERSION_1_2 ===
-  using VULKAN_HPP_NAMESPACE::MaxDriverInfoSize;
-  using VULKAN_HPP_NAMESPACE::MaxDriverNameSize;
-
-  //=== VK_KHR_device_group_creation ===
-  using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSizeKHR;
-
-  //=== VK_KHR_external_memory_capabilities ===
-  using VULKAN_HPP_NAMESPACE::LuidSizeKHR;
-
-  //=== VK_KHR_external_memory ===
-  using VULKAN_HPP_NAMESPACE::QueueFamilyExternalKHR;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_AMDX_shader_enqueue ===
-  using VULKAN_HPP_NAMESPACE::ShaderIndexUnusedAMDX;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_KHR_ray_tracing_pipeline ===
-  using VULKAN_HPP_NAMESPACE::ShaderUnusedKHR;
-
-  //=== VK_NV_ray_tracing ===
-  using VULKAN_HPP_NAMESPACE::ShaderUnusedNV;
-
-  //=== VK_KHR_global_priority ===
-  using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKHR;
-
-  //=== VK_KHR_driver_properties ===
-  using VULKAN_HPP_NAMESPACE::MaxDriverInfoSizeKHR;
-  using VULKAN_HPP_NAMESPACE::MaxDriverNameSizeKHR;
-
-  //=== VK_EXT_global_priority_query ===
-  using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeEXT;
-
-  //=== VK_EXT_image_sliced_view_of_3d ===
-  using VULKAN_HPP_NAMESPACE::Remaining3DSlicesEXT;
-
-  //=== VK_EXT_shader_module_identifier ===
-  using VULKAN_HPP_NAMESPACE::MaxShaderModuleIdentifierSizeEXT;
-
-  //========================
-  //=== CONSTEXPR VALUEs ===
-  //========================
-  using VULKAN_HPP_NAMESPACE::HeaderVersion;
-
-  //=========================
-  //=== CONSTEXPR CALLEEs ===
-  //=========================
-  using VULKAN_HPP_NAMESPACE::apiVersionMajor;
-  using VULKAN_HPP_NAMESPACE::apiVersionMinor;
-  using VULKAN_HPP_NAMESPACE::apiVersionPatch;
-  using VULKAN_HPP_NAMESPACE::apiVersionVariant;
-  using VULKAN_HPP_NAMESPACE::makeApiVersion;
-  using VULKAN_HPP_NAMESPACE::makeVersion;
-  using VULKAN_HPP_NAMESPACE::versionMajor;
-  using VULKAN_HPP_NAMESPACE::versionMinor;
-  using VULKAN_HPP_NAMESPACE::versionPatch;
-
-  //==========================
-  //=== CONSTEXPR CALLERSs ===
-  //==========================
-  using VULKAN_HPP_NAMESPACE::ApiVersion;
-  using VULKAN_HPP_NAMESPACE::ApiVersion10;
-  using VULKAN_HPP_NAMESPACE::ApiVersion11;
-  using VULKAN_HPP_NAMESPACE::ApiVersion12;
-  using VULKAN_HPP_NAMESPACE::ApiVersion13;
-  using VULKAN_HPP_NAMESPACE::HeaderVersionComplete;
-
-  //===============
-  //=== STRUCTs ===
-  //===============
-
-  //=== VK_VERSION_1_0 ===
-  using VULKAN_HPP_NAMESPACE::AllocationCallbacks;
-  using VULKAN_HPP_NAMESPACE::ApplicationInfo;
-  using VULKAN_HPP_NAMESPACE::AttachmentDescription;
-  using VULKAN_HPP_NAMESPACE::AttachmentReference;
-  using VULKAN_HPP_NAMESPACE::BaseInStructure;
-  using VULKAN_HPP_NAMESPACE::BaseOutStructure;
-  using VULKAN_HPP_NAMESPACE::BindSparseInfo;
-  using VULKAN_HPP_NAMESPACE::BufferCopy;
-  using VULKAN_HPP_NAMESPACE::BufferCreateInfo;
-  using VULKAN_HPP_NAMESPACE::BufferImageCopy;
-  using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier;
-  using VULKAN_HPP_NAMESPACE::BufferViewCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ClearAttachment;
-  using VULKAN_HPP_NAMESPACE::ClearColorValue;
-  using VULKAN_HPP_NAMESPACE::ClearDepthStencilValue;
-  using VULKAN_HPP_NAMESPACE::ClearRect;
-  using VULKAN_HPP_NAMESPACE::ClearValue;
-  using VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo;
-  using VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo;
-  using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo;
-  using VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ComponentMapping;
-  using VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo;
-  using VULKAN_HPP_NAMESPACE::CopyDescriptorSet;
-  using VULKAN_HPP_NAMESPACE::DescriptorBufferInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorImageInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolSize;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DispatchIndirectCommand;
-  using VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand;
-  using VULKAN_HPP_NAMESPACE::DrawIndirectCommand;
-  using VULKAN_HPP_NAMESPACE::EventCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ExtensionProperties;
-  using VULKAN_HPP_NAMESPACE::Extent2D;
-  using VULKAN_HPP_NAMESPACE::Extent3D;
-  using VULKAN_HPP_NAMESPACE::FenceCreateInfo;
-  using VULKAN_HPP_NAMESPACE::FormatProperties;
-  using VULKAN_HPP_NAMESPACE::FramebufferCreateInfo;
-  using VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ImageBlit;
-  using VULKAN_HPP_NAMESPACE::ImageCopy;
-  using VULKAN_HPP_NAMESPACE::ImageCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ImageFormatProperties;
-  using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier;
-  using VULKAN_HPP_NAMESPACE::ImageResolve;
-  using VULKAN_HPP_NAMESPACE::ImageSubresource;
-  using VULKAN_HPP_NAMESPACE::ImageSubresourceLayers;
-  using VULKAN_HPP_NAMESPACE::ImageSubresourceRange;
-  using VULKAN_HPP_NAMESPACE::ImageViewCreateInfo;
-  using VULKAN_HPP_NAMESPACE::InstanceCreateInfo;
-  using VULKAN_HPP_NAMESPACE::LayerProperties;
-  using VULKAN_HPP_NAMESPACE::MappedMemoryRange;
-  using VULKAN_HPP_NAMESPACE::MemoryAllocateInfo;
-  using VULKAN_HPP_NAMESPACE::MemoryBarrier;
-  using VULKAN_HPP_NAMESPACE::MemoryHeap;
-  using VULKAN_HPP_NAMESPACE::MemoryRequirements;
-  using VULKAN_HPP_NAMESPACE::MemoryType;
-  using VULKAN_HPP_NAMESPACE::Offset2D;
-  using VULKAN_HPP_NAMESPACE::Offset3D;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties;
-  using VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne;
-  using VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState;
-  using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PushConstantRange;
-  using VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyProperties;
-  using VULKAN_HPP_NAMESPACE::Rect2D;
-  using VULKAN_HPP_NAMESPACE::RenderPassBeginInfo;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo;
-  using VULKAN_HPP_NAMESPACE::SamplerCreateInfo;
-  using VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo;
-  using VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo;
-  using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties;
-  using VULKAN_HPP_NAMESPACE::SparseImageMemoryBind;
-  using VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo;
-  using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements;
-  using VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo;
-  using VULKAN_HPP_NAMESPACE::SparseMemoryBind;
-  using VULKAN_HPP_NAMESPACE::SpecializationInfo;
-  using VULKAN_HPP_NAMESPACE::SpecializationMapEntry;
-  using VULKAN_HPP_NAMESPACE::StencilOpState;
-  using VULKAN_HPP_NAMESPACE::SubmitInfo;
-  using VULKAN_HPP_NAMESPACE::SubpassDependency;
-  using VULKAN_HPP_NAMESPACE::SubpassDescription;
-  using VULKAN_HPP_NAMESPACE::SubresourceLayout;
-  using VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription;
-  using VULKAN_HPP_NAMESPACE::VertexInputBindingDescription;
-  using VULKAN_HPP_NAMESPACE::Viewport;
-  using VULKAN_HPP_NAMESPACE::WriteDescriptorSet;
-
-  //=== VK_VERSION_1_1 ===
-  using VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo;
-  using VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfoKHR;
-  using VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo;
-  using VULKAN_HPP_NAMESPACE::BindBufferMemoryInfoKHR;
-  using VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo;
-  using VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfoKHR;
-  using VULKAN_HPP_NAMESPACE::BindImageMemoryInfo;
-  using VULKAN_HPP_NAMESPACE::BindImageMemoryInfoKHR;
-  using VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo;
-  using VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfoKHR;
-  using VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2;
-  using VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupportKHR;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry;
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntryKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceQueueInfo2;
-  using VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ExportFenceCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo;
-  using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalBufferProperties;
-  using VULKAN_HPP_NAMESPACE::ExternalBufferPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalFenceProperties;
-  using VULKAN_HPP_NAMESPACE::ExternalFencePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties;
-  using VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryProperties;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties;
-  using VULKAN_HPP_NAMESPACE::ExternalSemaphorePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::FormatProperties2;
-  using VULKAN_HPP_NAMESPACE::FormatProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::ImageFormatProperties2;
-  using VULKAN_HPP_NAMESPACE::ImageFormatProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2;
-  using VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo;
-  using VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2;
-  using VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference;
-  using VULKAN_HPP_NAMESPACE::InputAttachmentAspectReferenceKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo;
-  using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfoKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo;
-  using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements;
-  using VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirementsKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryRequirements2;
-  using VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceIDPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3PropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParameterFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointerFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointerFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyProperties2;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo;
-  using VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo;
-  using VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2;
-  using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2;
-  using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2KHR;
-
-  //=== VK_VERSION_1_2 ===
-  using VULKAN_HPP_NAMESPACE::AttachmentDescription2;
-  using VULKAN_HPP_NAMESPACE::AttachmentDescription2KHR;
-  using VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout;
-  using VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayoutKHR;
-  using VULKAN_HPP_NAMESPACE::AttachmentReference2;
-  using VULKAN_HPP_NAMESPACE::AttachmentReference2KHR;
-  using VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout;
-  using VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayoutKHR;
-  using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo;
-  using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfoEXT;
-  using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfoKHR;
-  using VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo;
-  using VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ConformanceVersion;
-  using VULKAN_HPP_NAMESPACE::ConformanceVersionKHR;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupportEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo;
-  using VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfoKHR;
-  using VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo;
-  using VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfoKHR;
-  using VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo;
-  using VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo;
-  using VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo;
-  using VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolvePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloat16Int8FeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64FeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8FeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphorePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo;
-  using VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfoKHR;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo;
-  using VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo;
-  using VULKAN_HPP_NAMESPACE::SemaphoreSignalInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo;
-  using VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo;
-  using VULKAN_HPP_NAMESPACE::SemaphoreWaitInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SubpassBeginInfo;
-  using VULKAN_HPP_NAMESPACE::SubpassBeginInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SubpassDependency2;
-  using VULKAN_HPP_NAMESPACE::SubpassDependency2KHR;
-  using VULKAN_HPP_NAMESPACE::SubpassDescription2;
-  using VULKAN_HPP_NAMESPACE::SubpassDescription2KHR;
-  using VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve;
-  using VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolveKHR;
-  using VULKAN_HPP_NAMESPACE::SubpassEndInfo;
-  using VULKAN_HPP_NAMESPACE::SubpassEndInfoKHR;
-  using VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo;
-  using VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfoKHR;
-
-  //=== VK_VERSION_1_3 ===
-  using VULKAN_HPP_NAMESPACE::BlitImageInfo2;
-  using VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::BufferCopy2;
-  using VULKAN_HPP_NAMESPACE::BufferCopy2KHR;
-  using VULKAN_HPP_NAMESPACE::BufferImageCopy2;
-  using VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR;
-  using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2;
-  using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR;
-  using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo;
-  using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR;
-  using VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo;
-  using VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR;
-  using VULKAN_HPP_NAMESPACE::CopyBufferInfo2;
-  using VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2;
-  using VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::CopyImageInfo2;
-  using VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2;
-  using VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::DependencyInfo;
-  using VULKAN_HPP_NAMESPACE::DependencyInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements;
-  using VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements;
-  using VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR;
-  using VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo;
-  using VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::FormatProperties3;
-  using VULKAN_HPP_NAMESPACE::FormatProperties3KHR;
-  using VULKAN_HPP_NAMESPACE::ImageBlit2;
-  using VULKAN_HPP_NAMESPACE::ImageBlit2KHR;
-  using VULKAN_HPP_NAMESPACE::ImageCopy2;
-  using VULKAN_HPP_NAMESPACE::ImageCopy2KHR;
-  using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2;
-  using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR;
-  using VULKAN_HPP_NAMESPACE::ImageResolve2;
-  using VULKAN_HPP_NAMESPACE::ImageResolve2KHR;
-  using VULKAN_HPP_NAMESPACE::MemoryBarrier2;
-  using VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineCreationFeedback;
-  using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo;
-  using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::RenderingAttachmentInfo;
-  using VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR;
-  using VULKAN_HPP_NAMESPACE::RenderingInfo;
-  using VULKAN_HPP_NAMESPACE::RenderingInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ResolveImageInfo2;
-  using VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo;
-  using VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ShaderRequiredSubgroupSizeCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SubmitInfo2;
-  using VULKAN_HPP_NAMESPACE::SubmitInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock;
-  using VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT;
-
-  //=== VK_KHR_surface ===
-  using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::SurfaceFormatKHR;
-
-  //=== VK_KHR_swapchain ===
-  using VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR;
-  using VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PresentInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR;
-
-  //=== VK_KHR_display ===
-  using VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR;
-
-  //=== VK_KHR_display_swapchain ===
-  using VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR;
-
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-  //=== VK_KHR_xlib_surface ===
-  using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR;
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-  //=== VK_KHR_xcb_surface ===
-  using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR;
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-  //=== VK_KHR_wayland_surface ===
-  using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR;
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-  //=== VK_KHR_android_surface ===
-  using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_KHR_win32_surface ===
-  using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_EXT_debug_report ===
-  using VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT;
-
-  //=== VK_AMD_rasterization_order ===
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD;
-
-  //=== VK_EXT_debug_marker ===
-  using VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT;
-
-  //=== VK_KHR_video_queue ===
-  using VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR;
-
-  //=== VK_KHR_video_decode_queue ===
-  using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR;
-
-  //=== VK_NV_dedicated_allocation ===
-  using VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV;
-
-  //=== VK_EXT_transform_feedback ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT;
-
-  //=== VK_NVX_binary_import ===
-  using VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX;
-  using VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX;
-  using VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX;
-
-  //=== VK_NVX_image_view_handle ===
-  using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX;
-  using VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_EXT_video_encode_h264 ===
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_EXT_video_encode_h265 ===
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_KHR_video_decode_h264 ===
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR;
-
-  //=== VK_AMD_texture_gather_bias_lod ===
-  using VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD;
-
-  //=== VK_AMD_shader_info ===
-  using VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD;
-  using VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD;
-
-  //=== VK_KHR_dynamic_rendering ===
-  using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
-  using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;
-  using VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX;
-  using VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT;
-  using VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR;
-
-#if defined( VK_USE_PLATFORM_GGP )
-  //=== VK_GGP_stream_descriptor_surface ===
-  using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP;
-#endif /*VK_USE_PLATFORM_GGP*/
-
-  //=== VK_NV_corner_sampled_image ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV;
-
-  //=== VK_NV_external_memory_capabilities ===
-  using VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV;
-
-  //=== VK_NV_external_memory ===
-  using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV;
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_NV_external_memory_win32 ===
-  using VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV;
-  using VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_NV_win32_keyed_mutex ===
-  using VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_EXT_validation_flags ===
-  using VULKAN_HPP_NAMESPACE::ValidationFlagsEXT;
-
-#if defined( VK_USE_PLATFORM_VI_NN )
-  //=== VK_NN_vi_surface ===
-  using VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN;
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-  //=== VK_EXT_astc_decode_mode ===
-  using VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT;
-
-  //=== VK_EXT_pipeline_robustness ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_KHR_external_memory_win32 ===
-  using VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_KHR_external_memory_fd ===
-  using VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_KHR_win32_keyed_mutex ===
-  using VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_KHR_external_semaphore_win32 ===
-  using VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_KHR_external_semaphore_fd ===
-  using VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR;
-
-  //=== VK_KHR_push_descriptor ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR;
-
-  //=== VK_EXT_conditional_rendering ===
-  using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT;
-
-  //=== VK_KHR_incremental_present ===
-  using VULKAN_HPP_NAMESPACE::PresentRegionKHR;
-  using VULKAN_HPP_NAMESPACE::PresentRegionsKHR;
-  using VULKAN_HPP_NAMESPACE::RectLayerKHR;
-
-  //=== VK_NV_clip_space_w_scaling ===
-  using VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::ViewportWScalingNV;
-
-  //=== VK_EXT_display_surface_counter ===
-  using VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT;
-
-  //=== VK_EXT_display_control ===
-  using VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT;
-
-  //=== VK_GOOGLE_display_timing ===
-  using VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE;
-  using VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE;
-  using VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE;
-  using VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE;
-
-  //=== VK_NVX_multiview_per_view_attributes ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
-
-  //=== VK_NV_viewport_swizzle ===
-  using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::ViewportSwizzleNV;
-
-  //=== VK_EXT_discard_rectangles ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT;
-
-  //=== VK_EXT_conservative_rasterization ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT;
-
-  //=== VK_EXT_depth_clip_enable ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT;
-
-  //=== VK_EXT_hdr_metadata ===
-  using VULKAN_HPP_NAMESPACE::HdrMetadataEXT;
-  using VULKAN_HPP_NAMESPACE::XYColorEXT;
-
-  //=== VK_KHR_shared_presentable_image ===
-  using VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_KHR_external_fence_win32 ===
-  using VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR;
-  using VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_KHR_external_fence_fd ===
-  using VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR;
-
-  //=== VK_KHR_performance_query ===
-  using VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR;
-  using VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR;
-
-  //=== VK_KHR_get_surface_capabilities2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR;
-  using VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR;
-
-  //=== VK_KHR_get_display_properties2 ===
-  using VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR;
-  using VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR;
-  using VULKAN_HPP_NAMESPACE::DisplayProperties2KHR;
-
-#if defined( VK_USE_PLATFORM_IOS_MVK )
-  //=== VK_MVK_ios_surface ===
-  using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK;
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#if defined( VK_USE_PLATFORM_MACOS_MVK )
-  //=== VK_MVK_macos_surface ===
-  using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK;
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-  //=== VK_EXT_debug_utils ===
-  using VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT;
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
-  using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID;
-  using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID;
-  using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID;
-  using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID;
-  using VULKAN_HPP_NAMESPACE::ExternalFormatANDROID;
-  using VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID;
-  using VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_AMDX_shader_enqueue ===
-  using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstAMDX;
-  using VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX;
-  using VULKAN_HPP_NAMESPACE::DispatchGraphInfoAMDX;
-  using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX;
-  using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX;
-  using VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_EXT_sample_locations ===
-  using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
-  using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SampleLocationEXT;
-  using VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT;
-
-  //=== VK_EXT_blend_operation_advanced ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT;
-
-  //=== VK_NV_fragment_coverage_to_color ===
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV;
-
-  //=== VK_KHR_acceleration_structure ===
-  using VULKAN_HPP_NAMESPACE::AabbPositionsKHR;
-  using VULKAN_HPP_NAMESPACE::AabbPositionsNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR;
-  using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR;
-  using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR;
-  using VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::TransformMatrixKHR;
-  using VULKAN_HPP_NAMESPACE::TransformMatrixNV;
-  using VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR;
-
-  //=== VK_KHR_ray_tracing_pipeline ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR;
-  using VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR;
-
-  //=== VK_KHR_ray_query ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR;
-
-  //=== VK_NV_framebuffer_mixed_samples ===
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV;
-
-  //=== VK_NV_shader_sm_builtins ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV;
-
-  //=== VK_EXT_image_drm_format_modifier ===
-  using VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT;
-  using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT;
-  using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT;
-  using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT;
-
-  //=== VK_EXT_validation_cache ===
-  using VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_KHR_portability_subset ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_NV_shading_rate_image ===
-  using VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV;
-  using VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV;
-
-  //=== VK_NV_ray_tracing ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV;
-  using VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV;
-  using VULKAN_HPP_NAMESPACE::GeometryAABBNV;
-  using VULKAN_HPP_NAMESPACE::GeometryDataNV;
-  using VULKAN_HPP_NAMESPACE::GeometryNV;
-  using VULKAN_HPP_NAMESPACE::GeometryTrianglesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV;
-  using VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV;
-
-  //=== VK_NV_representative_fragment_test ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV;
-
-  //=== VK_EXT_filter_cubic ===
-  using VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT;
-
-  //=== VK_EXT_external_memory_host ===
-  using VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT;
-
-  //=== VK_KHR_shader_clock ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR;
-
-  //=== VK_AMD_pipeline_compiler_control ===
-  using VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD;
-
-  //=== VK_EXT_calibrated_timestamps ===
-  using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT;
-
-  //=== VK_AMD_shader_core_properties ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD;
-
-  //=== VK_KHR_video_decode_h265 ===
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR;
-
-  //=== VK_KHR_global_priority ===
-  using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR;
-
-  //=== VK_AMD_memory_overallocation_behavior ===
-  using VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD;
-
-  //=== VK_EXT_vertex_attribute_divisor ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT;
-
-#if defined( VK_USE_PLATFORM_GGP )
-  //=== VK_GGP_frame_token ===
-  using VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP;
-#endif /*VK_USE_PLATFORM_GGP*/
-
-  //=== VK_NV_compute_shader_derivatives ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV;
-
-  //=== VK_NV_mesh_shader ===
-  using VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV;
-
-  //=== VK_NV_shader_image_footprint ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV;
-
-  //=== VK_NV_scissor_exclusive ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV;
-
-  //=== VK_NV_device_diagnostic_checkpoints ===
-  using VULKAN_HPP_NAMESPACE::CheckpointDataNV;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV;
-
-  //=== VK_INTEL_shader_integer_functions2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
-
-  //=== VK_INTEL_performance_query ===
-  using VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL;
-  using VULKAN_HPP_NAMESPACE::PerformanceValueINTEL;
-  using VULKAN_HPP_NAMESPACE::QueryPoolCreateInfoINTEL;
-  using VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL;
-
-  //=== VK_EXT_pci_bus_info ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT;
-
-  //=== VK_AMD_display_native_hdr ===
-  using VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD;
-  using VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD;
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_imagepipe_surface ===
-  using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-  //=== VK_EXT_metal_surface ===
-  using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT;
-#endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-  //=== VK_EXT_fragment_density_map ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT;
-
-  //=== VK_KHR_fragment_shading_rate ===
-  using VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR;
-
-  //=== VK_AMD_shader_core_properties2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD;
-
-  //=== VK_AMD_device_coherent_memory ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD;
-
-  //=== VK_EXT_shader_image_atomic_int64 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
-
-  //=== VK_EXT_memory_budget ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT;
-
-  //=== VK_EXT_memory_priority ===
-  using VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT;
-
-  //=== VK_KHR_surface_protected_capabilities ===
-  using VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR;
-
-  //=== VK_NV_dedicated_allocation_image_aliasing ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
-
-  //=== VK_EXT_buffer_device_address ===
-  using VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferAddressFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT;
-
-  //=== VK_EXT_validation_features ===
-  using VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT;
-
-  //=== VK_KHR_present_wait ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR;
-
-  //=== VK_NV_cooperative_matrix ===
-  using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV;
-
-  //=== VK_NV_coverage_reduction_mode ===
-  using VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV;
-
-  //=== VK_EXT_fragment_shader_interlock ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
-
-  //=== VK_EXT_ycbcr_image_arrays ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT;
-
-  //=== VK_EXT_provoking_vertex ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  //=== VK_EXT_full_screen_exclusive ===
-  using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT;
-  using VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  //=== VK_EXT_headless_surface ===
-  using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT;
-
-  //=== VK_EXT_line_rasterization ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT;
-
-  //=== VK_EXT_shader_atomic_float ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT;
-
-  //=== VK_EXT_index_type_uint8 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT;
-
-  //=== VK_EXT_extended_dynamic_state ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT;
-
-  //=== VK_KHR_pipeline_executable_properties ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineInfoKHR;
-
-  //=== VK_EXT_host_image_copy ===
-  using VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT;
-  using VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT;
-  using VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT;
-  using VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT;
-  using VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT;
-  using VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT;
-
-  //=== VK_KHR_map_memory2 ===
-  using VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR;
-  using VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR;
-
-  //=== VK_EXT_shader_atomic_float2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
-
-  //=== VK_EXT_surface_maintenance1 ===
-  using VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT;
-  using VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT;
-  using VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT;
-
-  //=== VK_EXT_swapchain_maintenance1 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT;
-
-  //=== VK_NV_device_generated_commands ===
-  using VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV;
-  using VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV;
-  using VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV;
-  using VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV;
-  using VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV;
-  using VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV;
-  using VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
-  using VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV;
-
-  //=== VK_NV_inherited_viewport_scissor ===
-  using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV;
-
-  //=== VK_EXT_texel_buffer_alignment ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
-
-  //=== VK_QCOM_render_pass_transform ===
-  using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM;
-  using VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM;
-
-  //=== VK_EXT_depth_bias_control ===
-  using VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT;
-
-  //=== VK_EXT_device_memory_report ===
-  using VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT;
-
-  //=== VK_EXT_robustness2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT;
-
-  //=== VK_EXT_custom_border_color ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT;
-
-  //=== VK_KHR_pipeline_library ===
-  using VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR;
-
-  //=== VK_NV_present_barrier ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV;
-  using VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV;
-
-  //=== VK_KHR_present_id ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PresentIdKHR;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_KHR_video_encode_queue ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
-  using VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR;
-  using VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_NV_device_diagnostics_config ===
-  using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV;
-
-  //=== VK_NV_low_latency ===
-  using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV;
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-  //=== VK_EXT_metal_objects ===
-  using VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT;
-#endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-  //=== VK_KHR_synchronization2 ===
-  using VULKAN_HPP_NAMESPACE::CheckpointData2NV;
-  using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV;
-
-  //=== VK_EXT_descriptor_buffer ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT;
-  using VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorDataEXT;
-  using VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT;
-  using VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT;
-
-  //=== VK_EXT_graphics_pipeline_library ===
-  using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
-
-  //=== VK_AMD_shader_early_and_late_fragment_tests ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
-
-  //=== VK_KHR_fragment_shader_barycentric ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
-
-  //=== VK_KHR_shader_subgroup_uniform_control_flow ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
-
-  //=== VK_NV_fragment_shading_rate_enums ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
-  using VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV;
-
-  //=== VK_NV_ray_tracing_motion_blur ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMotionTrianglesDataNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceNV;
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::SRTDataNV;
-
-  //=== VK_EXT_mesh_shader ===
-  using VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT;
-
-  //=== VK_EXT_ycbcr_2plane_444_formats ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
-
-  //=== VK_EXT_fragment_density_map2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT;
-
-  //=== VK_QCOM_rotated_copy_commands ===
-  using VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM;
-
-  //=== VK_KHR_workgroup_memory_explicit_layout ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
-
-  //=== VK_EXT_image_compression_control ===
-  using VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT;
-  using VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT;
-
-  //=== VK_EXT_attachment_feedback_loop_layout ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
-
-  //=== VK_EXT_4444_formats ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT;
-
-  //=== VK_EXT_device_fault ===
-  using VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT;
-  using VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT;
-
-  //=== VK_EXT_rgba10x6_formats ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
-
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-  //=== VK_EXT_directfb_surface ===
-  using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT;
-#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-  //=== VK_EXT_vertex_input_dynamic_state ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT;
-  using VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT;
-
-  //=== VK_EXT_physical_device_drm ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT;
-
-  //=== VK_EXT_device_address_binding_report ===
-  using VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT;
-
-  //=== VK_EXT_depth_clip_control ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT;
-
-  //=== VK_EXT_primitive_topology_list_restart ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_external_memory ===
-  using VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_external_semaphore ===
-  using VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_buffer_collection ===
-  using VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA;
-  using VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  //=== VK_HUAWEI_subpass_shading ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI;
-  using VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI;
-
-  //=== VK_HUAWEI_invocation_mask ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI;
-
-  //=== VK_NV_external_memory_rdma ===
-  using VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV;
-
-  //=== VK_EXT_pipeline_properties ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT;
-
-  //=== VK_EXT_frame_boundary ===
-  using VULKAN_HPP_NAMESPACE::FrameBoundaryEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT;
-
-  //=== VK_EXT_multisampled_render_to_single_sampled ===
-  using VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT;
-
-  //=== VK_EXT_extended_dynamic_state2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT;
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-  //=== VK_QNX_screen_surface ===
-  using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX;
-#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-  //=== VK_EXT_color_write_enable ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT;
-
-  //=== VK_EXT_primitives_generated_query ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
-
-  //=== VK_KHR_ray_tracing_maintenance1 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR;
-
-  //=== VK_EXT_image_view_min_lod ===
-  using VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT;
-
-  //=== VK_EXT_multi_draw ===
-  using VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT;
-
-  //=== VK_EXT_image_2d_view_of_3d ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT;
-
-  //=== VK_EXT_shader_tile_image ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT;
-
-  //=== VK_EXT_opacity_micromap ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapEXT;
-  using VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT;
-  using VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT;
-  using VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapTriangleEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapUsageEXT;
-  using VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_NV_displacement_micromap ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesDisplacementMicromapNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_HUAWEI_cluster_culling_shader ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
-
-  //=== VK_EXT_border_color_swizzle ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT;
-
-  //=== VK_EXT_pageable_device_local_memory ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
-
-  //=== VK_ARM_shader_core_properties ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM;
-
-  //=== VK_EXT_image_sliced_view_of_3d ===
-  using VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
-
-  //=== VK_VALVE_descriptor_set_host_mapping ===
-  using VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
-
-  //=== VK_EXT_depth_clamp_zero_one ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT;
-
-  //=== VK_EXT_non_seamless_cube_map ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
-
-  //=== VK_QCOM_fragment_density_map_offset ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
-  using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
-
-  //=== VK_NV_copy_memory_indirect ===
-  using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
-  using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV;
-
-  //=== VK_NV_memory_decompression ===
-  using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV;
-
-  //=== VK_NV_device_generated_commands_compute ===
-  using VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV;
-  using VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV;
-
-  //=== VK_NV_linear_color_attachment ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV;
-
-  //=== VK_EXT_image_compression_control_swapchain ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
-
-  //=== VK_QCOM_image_processing ===
-  using VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM;
-
-  //=== VK_EXT_nested_command_buffer ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT;
-
-  //=== VK_EXT_external_memory_acquire_unmodified ===
-  using VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT;
-
-  //=== VK_EXT_extended_dynamic_state3 ===
-  using VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT;
-  using VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT;
-
-  //=== VK_EXT_subpass_merge_feedback ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT;
-  using VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT;
-
-  //=== VK_LUNARG_direct_driver_loading ===
-  using VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG;
-  using VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG;
-
-  //=== VK_EXT_shader_module_identifier ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT;
-
-  //=== VK_EXT_rasterization_order_attachment_access ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
-
-  //=== VK_NV_optical_flow ===
-  using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV;
-  using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV;
-
-  //=== VK_EXT_legacy_dithering ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT;
-
-  //=== VK_EXT_pipeline_protected_access ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT;
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-  //=== VK_ANDROID_external_format_resolve ===
-  using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-  //=== VK_KHR_maintenance5 ===
-  using VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR;
-  using VULKAN_HPP_NAMESPACE::ImageSubresource2EXT;
-  using VULKAN_HPP_NAMESPACE::ImageSubresource2KHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR;
-  using VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR;
-  using VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT;
-  using VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR;
-
-  //=== VK_KHR_ray_tracing_position_fetch ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
-
-  //=== VK_EXT_shader_object ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT;
-
-  //=== VK_QCOM_tile_properties ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::TilePropertiesQCOM;
-
-  //=== VK_SEC_amigo_profiling ===
-  using VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC;
-
-  //=== VK_QCOM_multiview_per_view_viewports ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
-
-  //=== VK_NV_ray_tracing_invocation_reorder ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
-
-  //=== VK_NV_extended_sparse_address_space ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
-
-  //=== VK_EXT_mutable_descriptor_type ===
-  using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT;
-  using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE;
-  using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT;
-  using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
-
-  //=== VK_ARM_shader_core_builtins ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
-
-  //=== VK_EXT_pipeline_library_group_handles ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
-
-  //=== VK_EXT_dynamic_rendering_unused_attachments ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
-
-  //=== VK_NV_low_latency2 ===
-  using VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV;
-  using VULKAN_HPP_NAMESPACE::LatencySleepInfoNV;
-  using VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV;
-  using VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV;
-  using VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV;
-  using VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV;
-  using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV;
-  using VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV;
-  using VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV;
-
-  //=== VK_KHR_cooperative_matrix ===
-  using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR;
-
-  //=== VK_QCOM_multiview_per_view_render_areas ===
-  using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
-
-  //=== VK_QCOM_image_processing2 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM;
-  using VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM;
-
-  //=== VK_QCOM_filter_cubic_weights ===
-  using VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM;
-
-  //=== VK_QCOM_ycbcr_degamma ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
-
-  //=== VK_QCOM_filter_cubic_clamp ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM;
-
-  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-  //=== VK_QNX_external_memory_screen_buffer ===
-  using VULKAN_HPP_NAMESPACE::ExternalFormatQNX;
-  using VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
-  using VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX;
-  using VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX;
-#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-  //=== VK_MSFT_layered_driver ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT;
-
-  //=== VK_NV_descriptor_pool_overallocation ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
-
-  //===============
-  //=== HANDLEs ===
-  //===============
-
-  using VULKAN_HPP_NAMESPACE::isVulkanHandleType;
-
-  //=== VK_VERSION_1_0 ===
-  using VULKAN_HPP_NAMESPACE::Buffer;
-  using VULKAN_HPP_NAMESPACE::BufferView;
-  using VULKAN_HPP_NAMESPACE::CommandBuffer;
-  using VULKAN_HPP_NAMESPACE::CommandPool;
-  using VULKAN_HPP_NAMESPACE::DescriptorPool;
-  using VULKAN_HPP_NAMESPACE::DescriptorSet;
-  using VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
-  using VULKAN_HPP_NAMESPACE::Device;
-  using VULKAN_HPP_NAMESPACE::DeviceMemory;
-  using VULKAN_HPP_NAMESPACE::Event;
-  using VULKAN_HPP_NAMESPACE::Fence;
-  using VULKAN_HPP_NAMESPACE::Framebuffer;
-  using VULKAN_HPP_NAMESPACE::Image;
-  using VULKAN_HPP_NAMESPACE::ImageView;
-  using VULKAN_HPP_NAMESPACE::Instance;
-  using VULKAN_HPP_NAMESPACE::PhysicalDevice;
-  using VULKAN_HPP_NAMESPACE::Pipeline;
-  using VULKAN_HPP_NAMESPACE::PipelineCache;
-  using VULKAN_HPP_NAMESPACE::PipelineLayout;
-  using VULKAN_HPP_NAMESPACE::QueryPool;
-  using VULKAN_HPP_NAMESPACE::Queue;
-  using VULKAN_HPP_NAMESPACE::RenderPass;
-  using VULKAN_HPP_NAMESPACE::Sampler;
-  using VULKAN_HPP_NAMESPACE::Semaphore;
-  using VULKAN_HPP_NAMESPACE::ShaderModule;
-
-  //=== VK_VERSION_1_1 ===
-  using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
-  using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
-
-  //=== VK_VERSION_1_3 ===
-  using VULKAN_HPP_NAMESPACE::PrivateDataSlot;
-
-  //=== VK_KHR_surface ===
-  using VULKAN_HPP_NAMESPACE::SurfaceKHR;
-
-  //=== VK_KHR_swapchain ===
-  using VULKAN_HPP_NAMESPACE::SwapchainKHR;
-
-  //=== VK_KHR_display ===
-  using VULKAN_HPP_NAMESPACE::DisplayKHR;
-  using VULKAN_HPP_NAMESPACE::DisplayModeKHR;
-
-  //=== VK_EXT_debug_report ===
-  using VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
-
-  //=== VK_KHR_video_queue ===
-  using VULKAN_HPP_NAMESPACE::VideoSessionKHR;
-  using VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
-
-  //=== VK_NVX_binary_import ===
-  using VULKAN_HPP_NAMESPACE::CuFunctionNVX;
-  using VULKAN_HPP_NAMESPACE::CuModuleNVX;
-
-  //=== VK_EXT_debug_utils ===
-  using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
-
-  //=== VK_KHR_acceleration_structure ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
-
-  //=== VK_EXT_validation_cache ===
-  using VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
-
-  //=== VK_NV_ray_tracing ===
-  using VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
-
-  //=== VK_INTEL_performance_query ===
-  using VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
-
-  //=== VK_KHR_deferred_host_operations ===
-  using VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
-
-  //=== VK_NV_device_generated_commands ===
-  using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_buffer_collection ===
-  using VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  //=== VK_EXT_opacity_micromap ===
-  using VULKAN_HPP_NAMESPACE::MicromapEXT;
-
-  //=== VK_NV_optical_flow ===
-  using VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
-
-  //=== VK_EXT_shader_object ===
-  using VULKAN_HPP_NAMESPACE::ShaderEXT;
-
-  //======================
-  //=== UNIQUE HANDLEs ===
-  //======================
-
-#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-
-  //=== VK_VERSION_1_0 ===
-  using VULKAN_HPP_NAMESPACE::UniqueBuffer;
-  using VULKAN_HPP_NAMESPACE::UniqueBufferView;
-  using VULKAN_HPP_NAMESPACE::UniqueCommandBuffer;
-  using VULKAN_HPP_NAMESPACE::UniqueCommandPool;
-  using VULKAN_HPP_NAMESPACE::UniqueDescriptorPool;
-  using VULKAN_HPP_NAMESPACE::UniqueDescriptorSet;
-  using VULKAN_HPP_NAMESPACE::UniqueDescriptorSetLayout;
-  using VULKAN_HPP_NAMESPACE::UniqueDevice;
-  using VULKAN_HPP_NAMESPACE::UniqueDeviceMemory;
-  using VULKAN_HPP_NAMESPACE::UniqueEvent;
-  using VULKAN_HPP_NAMESPACE::UniqueFence;
-  using VULKAN_HPP_NAMESPACE::UniqueFramebuffer;
-  using VULKAN_HPP_NAMESPACE::UniqueImage;
-  using VULKAN_HPP_NAMESPACE::UniqueImageView;
-  using VULKAN_HPP_NAMESPACE::UniqueInstance;
-  using VULKAN_HPP_NAMESPACE::UniquePipeline;
-  using VULKAN_HPP_NAMESPACE::UniquePipelineCache;
-  using VULKAN_HPP_NAMESPACE::UniquePipelineLayout;
-  using VULKAN_HPP_NAMESPACE::UniqueQueryPool;
-  using VULKAN_HPP_NAMESPACE::UniqueRenderPass;
-  using VULKAN_HPP_NAMESPACE::UniqueSampler;
-  using VULKAN_HPP_NAMESPACE::UniqueSemaphore;
-  using VULKAN_HPP_NAMESPACE::UniqueShaderModule;
-
-  //=== VK_VERSION_1_1 ===
-  using VULKAN_HPP_NAMESPACE::UniqueDescriptorUpdateTemplate;
-  using VULKAN_HPP_NAMESPACE::UniqueSamplerYcbcrConversion;
-
-  //=== VK_VERSION_1_3 ===
-  using VULKAN_HPP_NAMESPACE::UniquePrivateDataSlot;
-
-  //=== VK_KHR_surface ===
-  using VULKAN_HPP_NAMESPACE::UniqueSurfaceKHR;
-
-  //=== VK_KHR_swapchain ===
-  using VULKAN_HPP_NAMESPACE::UniqueSwapchainKHR;
-
-  //=== VK_EXT_debug_report ===
-  using VULKAN_HPP_NAMESPACE::UniqueDebugReportCallbackEXT;
-
-  //=== VK_KHR_video_queue ===
-  using VULKAN_HPP_NAMESPACE::UniqueVideoSessionKHR;
-  using VULKAN_HPP_NAMESPACE::UniqueVideoSessionParametersKHR;
-
-  //=== VK_NVX_binary_import ===
-  using VULKAN_HPP_NAMESPACE::UniqueCuFunctionNVX;
-  using VULKAN_HPP_NAMESPACE::UniqueCuModuleNVX;
-
-  //=== VK_EXT_debug_utils ===
-  using VULKAN_HPP_NAMESPACE::UniqueDebugUtilsMessengerEXT;
-
-  //=== VK_KHR_acceleration_structure ===
-  using VULKAN_HPP_NAMESPACE::UniqueAccelerationStructureKHR;
-
-  //=== VK_EXT_validation_cache ===
-  using VULKAN_HPP_NAMESPACE::UniqueValidationCacheEXT;
-
-  //=== VK_NV_ray_tracing ===
-  using VULKAN_HPP_NAMESPACE::UniqueAccelerationStructureNV;
-
-  //=== VK_KHR_deferred_host_operations ===
-  using VULKAN_HPP_NAMESPACE::UniqueDeferredOperationKHR;
-
-  //=== VK_NV_device_generated_commands ===
-  using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutNV;
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_buffer_collection ===
-  using VULKAN_HPP_NAMESPACE::UniqueBufferCollectionFUCHSIA;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  //=== VK_EXT_opacity_micromap ===
-  using VULKAN_HPP_NAMESPACE::UniqueMicromapEXT;
-
-  //=== VK_NV_optical_flow ===
-  using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV;
-
-  //=== VK_EXT_shader_object ===
-  using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
-  using VULKAN_HPP_NAMESPACE::UniqueShaderEXT;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  //======================
-  //=== SHARED HANDLEs ===
-  //======================
-
-#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-
-  //=== VK_VERSION_1_0 ===
-  using VULKAN_HPP_NAMESPACE::SharedBuffer;
-  using VULKAN_HPP_NAMESPACE::SharedBufferView;
-  using VULKAN_HPP_NAMESPACE::SharedCommandBuffer;
-  using VULKAN_HPP_NAMESPACE::SharedCommandPool;
-  using VULKAN_HPP_NAMESPACE::SharedDescriptorPool;
-  using VULKAN_HPP_NAMESPACE::SharedDescriptorSet;
-  using VULKAN_HPP_NAMESPACE::SharedDescriptorSetLayout;
-  using VULKAN_HPP_NAMESPACE::SharedDevice;
-  using VULKAN_HPP_NAMESPACE::SharedDeviceMemory;
-  using VULKAN_HPP_NAMESPACE::SharedEvent;
-  using VULKAN_HPP_NAMESPACE::SharedFence;
-  using VULKAN_HPP_NAMESPACE::SharedFramebuffer;
-  using VULKAN_HPP_NAMESPACE::SharedImage;
-  using VULKAN_HPP_NAMESPACE::SharedImageView;
-  using VULKAN_HPP_NAMESPACE::SharedInstance;
-  using VULKAN_HPP_NAMESPACE::SharedPhysicalDevice;
-  using VULKAN_HPP_NAMESPACE::SharedPipeline;
-  using VULKAN_HPP_NAMESPACE::SharedPipelineCache;
-  using VULKAN_HPP_NAMESPACE::SharedPipelineLayout;
-  using VULKAN_HPP_NAMESPACE::SharedQueryPool;
-  using VULKAN_HPP_NAMESPACE::SharedQueue;
-  using VULKAN_HPP_NAMESPACE::SharedRenderPass;
-  using VULKAN_HPP_NAMESPACE::SharedSampler;
-  using VULKAN_HPP_NAMESPACE::SharedSemaphore;
-  using VULKAN_HPP_NAMESPACE::SharedShaderModule;
-
-  //=== VK_VERSION_1_1 ===
-  using VULKAN_HPP_NAMESPACE::SharedDescriptorUpdateTemplate;
-  using VULKAN_HPP_NAMESPACE::SharedSamplerYcbcrConversion;
-
-  //=== VK_VERSION_1_3 ===
-  using VULKAN_HPP_NAMESPACE::SharedPrivateDataSlot;
-
-  //=== VK_KHR_surface ===
-  using VULKAN_HPP_NAMESPACE::SharedSurfaceKHR;
-
-  //=== VK_KHR_swapchain ===
-  using VULKAN_HPP_NAMESPACE::SharedSwapchainKHR;
-
-  //=== VK_KHR_display ===
-  using VULKAN_HPP_NAMESPACE::SharedDisplayKHR;
-  using VULKAN_HPP_NAMESPACE::SharedDisplayModeKHR;
-
-  //=== VK_EXT_debug_report ===
-  using VULKAN_HPP_NAMESPACE::SharedDebugReportCallbackEXT;
-
-  //=== VK_KHR_video_queue ===
-  using VULKAN_HPP_NAMESPACE::SharedVideoSessionKHR;
-  using VULKAN_HPP_NAMESPACE::SharedVideoSessionParametersKHR;
-
-  //=== VK_NVX_binary_import ===
-  using VULKAN_HPP_NAMESPACE::SharedCuFunctionNVX;
-  using VULKAN_HPP_NAMESPACE::SharedCuModuleNVX;
-
-  //=== VK_EXT_debug_utils ===
-  using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT;
-
-  //=== VK_KHR_acceleration_structure ===
-  using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureKHR;
-
-  //=== VK_EXT_validation_cache ===
-  using VULKAN_HPP_NAMESPACE::SharedValidationCacheEXT;
-
-  //=== VK_NV_ray_tracing ===
-  using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureNV;
-
-  //=== VK_INTEL_performance_query ===
-  using VULKAN_HPP_NAMESPACE::SharedPerformanceConfigurationINTEL;
-
-  //=== VK_KHR_deferred_host_operations ===
-  using VULKAN_HPP_NAMESPACE::SharedDeferredOperationKHR;
-
-  //=== VK_NV_device_generated_commands ===
-  using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutNV;
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_buffer_collection ===
-  using VULKAN_HPP_NAMESPACE::SharedBufferCollectionFUCHSIA;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  //=== VK_EXT_opacity_micromap ===
-  using VULKAN_HPP_NAMESPACE::SharedMicromapEXT;
-
-  //=== VK_NV_optical_flow ===
-  using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV;
-
-  //=== VK_EXT_shader_object ===
-  using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
-  using VULKAN_HPP_NAMESPACE::SharedShaderEXT;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  //===========================
-  //=== COMMAND Definitions ===
-  //===========================
-  using VULKAN_HPP_NAMESPACE::createInstance;
-  using VULKAN_HPP_NAMESPACE::enumerateInstanceExtensionProperties;
-  using VULKAN_HPP_NAMESPACE::enumerateInstanceLayerProperties;
-  using VULKAN_HPP_NAMESPACE::enumerateInstanceVersion;
-
-#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-  using VULKAN_HPP_NAMESPACE::createInstanceUnique;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-  using VULKAN_HPP_NAMESPACE::StructExtends;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
-  using VULKAN_HPP_NAMESPACE::DynamicLoader;
-#endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/
-
-  //=====================
-  //=== Format Traits ===
-  //=====================
-  using VULKAN_HPP_NAMESPACE::blockExtent;
-  using VULKAN_HPP_NAMESPACE::blockSize;
-  using VULKAN_HPP_NAMESPACE::compatibilityClass;
-  using VULKAN_HPP_NAMESPACE::componentBits;
-  using VULKAN_HPP_NAMESPACE::componentCount;
-  using VULKAN_HPP_NAMESPACE::componentName;
-  using VULKAN_HPP_NAMESPACE::componentNumericFormat;
-  using VULKAN_HPP_NAMESPACE::componentPlaneIndex;
-  using VULKAN_HPP_NAMESPACE::componentsAreCompressed;
-  using VULKAN_HPP_NAMESPACE::compressionScheme;
-  using VULKAN_HPP_NAMESPACE::isCompressed;
-  using VULKAN_HPP_NAMESPACE::packed;
-  using VULKAN_HPP_NAMESPACE::planeCompatibleFormat;
-  using VULKAN_HPP_NAMESPACE::planeCount;
-  using VULKAN_HPP_NAMESPACE::planeHeightDivisor;
-  using VULKAN_HPP_NAMESPACE::planeWidthDivisor;
-  using VULKAN_HPP_NAMESPACE::texelsPerBlock;
-
-  //======================================
-  //=== Extension inspection functions ===
-  //======================================
-  using VULKAN_HPP_NAMESPACE::getDeprecatedExtensions;
-  using VULKAN_HPP_NAMESPACE::getDeviceExtensions;
-  using VULKAN_HPP_NAMESPACE::getExtensionDepends;
-  using VULKAN_HPP_NAMESPACE::getExtensionDeprecatedBy;
-  using VULKAN_HPP_NAMESPACE::getExtensionObsoletedBy;
-  using VULKAN_HPP_NAMESPACE::getExtensionPromotedTo;
-  using VULKAN_HPP_NAMESPACE::getInstanceExtensions;
-  using VULKAN_HPP_NAMESPACE::getObsoletedExtensions;
-  using VULKAN_HPP_NAMESPACE::getPromotedExtensions;
-  using VULKAN_HPP_NAMESPACE::isDeprecatedExtension;
-  using VULKAN_HPP_NAMESPACE::isDeviceExtension;
-  using VULKAN_HPP_NAMESPACE::isInstanceExtension;
-  using VULKAN_HPP_NAMESPACE::isObsoletedExtension;
-  using VULKAN_HPP_NAMESPACE::isPromotedExtension;
-
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !defined( VULKAN_HPP_NO_EXCEPTIONS )
-  namespace VULKAN_HPP_RAII_NAMESPACE
-  {
-    //======================
-    //=== RAII HARDCODED ===
-    //======================
-
-    using VULKAN_HPP_RAII_NAMESPACE::Context;
-    using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher;
-    using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher;
-    using VULKAN_HPP_RAII_NAMESPACE::exchange;
-    using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher;
-
-    //====================
-    //=== RAII HANDLEs ===
-    //====================
-
-    //=== VK_VERSION_1_0 ===
-    using VULKAN_HPP_RAII_NAMESPACE::Buffer;
-    using VULKAN_HPP_RAII_NAMESPACE::BufferView;
-    using VULKAN_HPP_RAII_NAMESPACE::CommandBuffer;
-    using VULKAN_HPP_RAII_NAMESPACE::CommandBuffers;
-    using VULKAN_HPP_RAII_NAMESPACE::CommandPool;
-    using VULKAN_HPP_RAII_NAMESPACE::DescriptorPool;
-    using VULKAN_HPP_RAII_NAMESPACE::DescriptorSet;
-    using VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout;
-    using VULKAN_HPP_RAII_NAMESPACE::DescriptorSets;
-    using VULKAN_HPP_RAII_NAMESPACE::Device;
-    using VULKAN_HPP_RAII_NAMESPACE::DeviceMemory;
-    using VULKAN_HPP_RAII_NAMESPACE::Event;
-    using VULKAN_HPP_RAII_NAMESPACE::Fence;
-    using VULKAN_HPP_RAII_NAMESPACE::Framebuffer;
-    using VULKAN_HPP_RAII_NAMESPACE::Image;
-    using VULKAN_HPP_RAII_NAMESPACE::ImageView;
-    using VULKAN_HPP_RAII_NAMESPACE::Instance;
-    using VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice;
-    using VULKAN_HPP_RAII_NAMESPACE::PhysicalDevices;
-    using VULKAN_HPP_RAII_NAMESPACE::Pipeline;
-    using VULKAN_HPP_RAII_NAMESPACE::PipelineCache;
-    using VULKAN_HPP_RAII_NAMESPACE::PipelineLayout;
-    using VULKAN_HPP_RAII_NAMESPACE::Pipelines;
-    using VULKAN_HPP_RAII_NAMESPACE::QueryPool;
-    using VULKAN_HPP_RAII_NAMESPACE::Queue;
-    using VULKAN_HPP_RAII_NAMESPACE::RenderPass;
-    using VULKAN_HPP_RAII_NAMESPACE::Sampler;
-    using VULKAN_HPP_RAII_NAMESPACE::Semaphore;
-    using VULKAN_HPP_RAII_NAMESPACE::ShaderModule;
-
-    //=== VK_VERSION_1_1 ===
-    using VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate;
-    using VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion;
-
-    //=== VK_VERSION_1_3 ===
-    using VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot;
-
-    //=== VK_KHR_surface ===
-    using VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR;
-
-    //=== VK_KHR_swapchain ===
-    using VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR;
-    using VULKAN_HPP_RAII_NAMESPACE::SwapchainKHRs;
-
-    //=== VK_KHR_display ===
-    using VULKAN_HPP_RAII_NAMESPACE::DisplayKHR;
-    using VULKAN_HPP_RAII_NAMESPACE::DisplayKHRs;
-    using VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR;
-
-    //=== VK_EXT_debug_report ===
-    using VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT;
-
-    //=== VK_KHR_video_queue ===
-    using VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR;
-    using VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR;
-
-    //=== VK_NVX_binary_import ===
-    using VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX;
-    using VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX;
-
-    //=== VK_EXT_debug_utils ===
-    using VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT;
-
-    //=== VK_KHR_acceleration_structure ===
-    using VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR;
-
-    //=== VK_EXT_validation_cache ===
-    using VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT;
-
-    //=== VK_NV_ray_tracing ===
-    using VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV;
-
-    //=== VK_INTEL_performance_query ===
-    using VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL;
-
-    //=== VK_KHR_deferred_host_operations ===
-    using VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR;
-
-    //=== VK_NV_device_generated_commands ===
-    using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV;
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_buffer_collection ===
-    using VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-    //=== VK_EXT_opacity_micromap ===
-    using VULKAN_HPP_RAII_NAMESPACE::MicromapEXT;
-
-    //=== VK_NV_optical_flow ===
-    using VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV;
-
-    //=== VK_EXT_shader_object ===
-    using VULKAN_HPP_RAII_NAMESPACE::ShaderEXT;
-    using VULKAN_HPP_RAII_NAMESPACE::ShaderEXTs;
-
-  }  // namespace VULKAN_HPP_RAII_NAMESPACE
-#endif
-}  // namespace VULKAN_HPP_NAMESPACE
-
diff --git a/modules/stormkit/Log/FileLogger.mpp b/modules/stormkit/Log/FileLogger.mpp
index 52232a2d..ff9b750c 100644
--- a/modules/stormkit/Log/FileLogger.mpp
+++ b/modules/stormkit/Log/FileLogger.mpp
@@ -12,7 +12,6 @@ import std;
 
 import stormkit.Core;
 
-
 import :Logger;
 import :Severity;
 
diff --git a/modules/stormkit/Log/Logger.mpp b/modules/stormkit/Log/Logger.mpp
index 1b462f43..52a75934 100644
--- a/modules/stormkit/Log/Logger.mpp
+++ b/modules/stormkit/Log/Logger.mpp
@@ -12,7 +12,6 @@ import std;
 
 import stormkit.Core;
 
-
 import :Severity;
 
 export namespace stormkit::log {
@@ -21,6 +20,7 @@ export namespace stormkit::log {
     class STORMKIT_API Logger {
       public:
         using LogClock = std::chrono::high_resolution_clock;
+
         explicit Logger(LogClock::time_point start) noexcept;
         Logger(LogClock::time_point start, Severity log_level) noexcept;
         virtual ~Logger();
@@ -104,26 +104,26 @@ export namespace stormkit::log {
 namespace stormkit::log {
     ////////////////////////////////////////
     ////////////////////////////////////////
-    inline auto Logger::setLogLevel(Severity log_level) noexcept -> void {
+    STORMKIT_FORCE_INLINE auto Logger::setLogLevel(Severity log_level) noexcept -> void {
         m_log_level = log_level;
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
-    inline auto Logger::startTime() const noexcept -> const LogClock::time_point& {
+    STORMKIT_FORCE_INLINE auto Logger::startTime() const noexcept -> const LogClock::time_point& {
         return m_start_time;
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
-    inline auto Logger::logLevel() const noexcept -> const Severity& {
+    STORMKIT_FORCE_INLINE auto Logger::logLevel() const noexcept -> const Severity& {
         return m_log_level;
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class T, typename... Args>
-    auto Logger::createLoggerInstance(Args&&...param_args) -> T {
+    STORMKIT_FORCE_INLINE auto Logger::createLoggerInstance(Args&&...param_args) -> T {
         using LogClock = std::chrono::high_resolution_clock;
         static_assert(std::is_base_of<Logger, T>::value, "T must inherit Logger");
 
@@ -135,7 +135,7 @@ namespace stormkit::log {
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class T, typename... Args>
-    auto Logger::allocateLoggerInstance(Args&&...param_args) -> std::unique_ptr<T> {
+    STORMKIT_FORCE_INLINE auto Logger::allocateLoggerInstance(Args&&...param_args) -> std::unique_ptr<T> {
         using LogClock = std::chrono::high_resolution_clock;
         static_assert(std::is_base_of<Logger, T>::value, "T must inherit Logger");
 
@@ -165,7 +165,7 @@ namespace stormkit::log {
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Logger::log(Severity severity, std::string_view format_string, Args&&...param_args)
+    STORMKIT_FORCE_INLINE auto Logger::log(Severity severity, std::string_view format_string, Args&&...param_args)
         -> void {
         log(severity, Module{}, format_string, std::forward<Args>(param_args)...);
     }
@@ -173,83 +173,83 @@ namespace stormkit::log {
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Logger::dlog(Args&&...param_args) -> void {
+    STORMKIT_FORCE_INLINE auto Logger::dlog(Args&&...param_args) -> void {
         log(Severity::Debug, std::forward<Args>(param_args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Logger::ilog(Args&&...param_args) -> void {
+    STORMKIT_FORCE_INLINE auto Logger::ilog(Args&&...param_args) -> void {
         log(Severity::Info, std::forward<Args>(param_args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Logger::wlog(Args&&...param_args) -> void {
+    STORMKIT_FORCE_INLINE auto Logger::wlog(Args&&...param_args) -> void {
         log(Severity::Warning, std::forward<Args>(param_args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Logger::elog(Args&&...param_args) -> void {
+    STORMKIT_FORCE_INLINE auto Logger::elog(Args&&...param_args) -> void {
         log(Severity::Error, std::forward<Args>(param_args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Logger::flog(Args&&...param_args) -> void {
+    STORMKIT_FORCE_INLINE auto Logger::flog(Args&&...param_args) -> void {
         log(Severity::Fatal, std::forward<Args>(param_args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Module::dlog(Args&&...args) const -> void {
+    STORMKIT_FORCE_INLINE auto Module::dlog(Args&&...args) const -> void {
         Logger::dlog(*this, std::forward<Args>(args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Module::ilog(Args&&...args) const -> void {
+    STORMKIT_FORCE_INLINE auto Module::ilog(Args&&...args) const -> void {
         Logger::ilog(*this, std::forward<Args>(args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Module::wlog(Args&&...args) const -> void {
+    STORMKIT_FORCE_INLINE auto Module::wlog(Args&&...args) const -> void {
         Logger::wlog(*this, std::forward<Args>(args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Module::elog(Args&&...args) const -> void {
+    STORMKIT_FORCE_INLINE auto Module::elog(Args&&...args) const -> void {
         Logger::elog(*this, std::forward<Args>(args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<class... Args>
-    auto Module::flog(Args&&...args) const -> void {
+    STORMKIT_FORCE_INLINE auto Module::flog(Args&&...args) const -> void {
         Logger::flog(*this, std::forward<Args>(args)...);
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
-    inline auto Module::flush() const -> void {
+    STORMKIT_FORCE_INLINE auto Module::flush() const -> void {
         Logger::instance().flush();
     }
 
     ////////////////////////////////////////
     ////////////////////////////////////////
     template<core::ConstexprString str>
-    constexpr auto operator"" _module() -> stormkit::log::Module {
+    STORMKIT_FORCE_INLINE constexpr auto operator"" _module() -> stormkit::log::Module {
         return Module { str.view() };
     }
 } // namespace stormkit::log
diff --git a/src/Gpu/Core/Device.cpp b/src/Gpu/Core/Device.cpp
index 3bb5023a..7171f8c8 100644
--- a/src/Gpu/Core/Device.cpp
+++ b/src/Gpu/Core/Device.cpp
@@ -13,8 +13,8 @@ import std;
 import stormkit.Core;
 import stormkit.Log;
 
-#include <stormkit/Log/LogMacro.hpp>
 #include <stormkit/Gpu/Core/VulkanMacro.hpp>
+#include <stormkit/Log/LogMacro.hpp>
 
 import :Core.Device;
 import :Core.Sync;
@@ -49,8 +49,8 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     Device::Device(const PhysicalDevice& physical_device,
-                   const Instance      & instance,
-                   const Info          & info,
+                   const Instance&       instance,
+                   const Info&           info,
                    Tag)
         : InstanceObject { instance }, m_physical_device { &physical_device } {
         const auto& queue_families = m_physical_device->queueFamilies();
@@ -193,18 +193,15 @@ namespace stormkit::gpu {
                                      .setPEnabledExtensionNames(extensions)
                                      .setPEnabledFeatures(&enabled_features);
 
-        vkCreate<vk::raii::Device>(m_physical_device->vkHandle(), create_info)
+        m_physical_device->vkHandle()
+            .createDevice(create_info)
             .transform(core::monadic::set(m_vk_device))
             .transform([this]() noexcept -> VulkanExpected<void> {
                 VULKAN_HPP_DEFAULT_DISPATCHER.init(*vkHandle());
 
-                try {
-                    m_vma_function_table =
-                        vma::functionsFromDispatcher(this->instance().vkHandle().getDispatcher(),
-                                                     vkHandle().getDispatcher());
-                } catch (const vk::SystemError& err) {
-                    return std::unexpected { core::narrow<vk::Result>(err.code().value()) };
-                }
+                m_vma_function_table =
+                    vma::functionsFromDispatcher(this->instance().vkHandle().getDispatcher(),
+                                                 vkHandle().getDispatcher());
 
                 const auto alloc_create_info =
                     vma::AllocatorCreateInfo {}
@@ -213,11 +210,8 @@ namespace stormkit::gpu {
                         .setDevice(*vkHandle())
                         .setPVulkanFunctions(&vmaFunctionTable());
 
-                try {
-                    m_vma_allocator = vma::createAllocatorUnique(alloc_create_info);
-                } catch (const vk::SystemError& err) {
-                    return std::unexpected { core::narrow<vk::Result>(err.code().value()) };
-                }
+                auto&& [result, m_vma_allocator] = vma::createAllocatorUnique(alloc_create_info);
+                if (result != vk::Result::eSuccess) return std::unexpected { result };
 
                 return {};
             })
@@ -231,13 +225,14 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     auto Device::waitForFences(std::span<const core::NakedRef<const Fence>> fences,
                                bool                                         wait_all,
-                               const std::chrono::milliseconds            & timeout) const noexcept
+                               const std::chrono::milliseconds&             timeout) const noexcept
         -> Expected<Result> {
         const auto vk_fences =
             fences | std::views::transform(toVkHandle()) | std::ranges::to<std::vector>();
 
         return vkCall(*m_vk_device,
                       &vk::raii::Device::waitForFences,
+                      { { vk::Result::eSuccess, vk::Result::eNotReady } },
                       vk_fences,
                       wait_all,
                       std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count())
@@ -248,27 +243,10 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     auto Device::resetFences(std::span<const core::NakedRef<const Fence>> fences) const noexcept
-        -> Expected<void> {
+        -> void {
         const auto vk_fences =
             fences | std::views::transform(toVkHandle()) | std::ranges::to<std::vector>();
 
-        return vkCall(*m_vk_device, &vk::raii::Device::resetFences, vk_fences)
-            .transform_error(core::monadic::as<Result>());
-    }
-
-    /////////////////////////////////////
-    /////////////////////////////////////
-    auto Device::setObjectName(core::UInt64     object,
-                               DebugObjectType  type,
-                               std::string_view name) const -> Expected<void> {
-        if (!vkHandle().getDispatcher()->vkSetDebugUtilsObjectNameEXT) return {};
-
-        const auto info = vk::DebugUtilsObjectNameInfoEXT {}
-                              .setObjectType(core::narrow<vk::ObjectType>(type))
-                              .setObjectHandle(object)
-                              .setPObjectName(std::data(name));
-
-        return vkCall(*m_vk_device, &vk::raii::Device::setDebugUtilsObjectNameEXT, info)
-            .transform_error(core::monadic::as<Result>());
+        m_vk_device->resetFences(vk_fences);
     }
 } // namespace stormkit::gpu
diff --git a/src/Gpu/Core/Instance.cpp b/src/Gpu/Core/Instance.cpp
index 1611fc8f..2795a481 100644
--- a/src/Gpu/Core/Instance.cpp
+++ b/src/Gpu/Core/Instance.cpp
@@ -35,8 +35,7 @@ namespace stormkit::gpu {
         constexpr auto STORMKIT_VK_VERSION =
             vkMakeVersion<core::Int32>(core::STORMKIT_MAJOR_VERSION,
                                        core::STORMKIT_MINOR_VERSION,
-                                       core::STORMKIT_PATCH_VERSION
-                                       );
+                                       core::STORMKIT_PATCH_VERSION);
 
         inline constexpr auto BASE_EXTENSIONS =
             std::array { "VK_KHR_get_physical_device_properties2" };
@@ -136,7 +135,7 @@ namespace stormkit::gpu {
         m_vk_context = vk::raii::Context();
 
         const auto exts = m_vk_context->enumerateInstanceExtensionProperties();
-        m_extensions    = exts | std::views::transform([](auto   &&extension) noexcept {
+        m_extensions    = exts | std::views::transform([](auto&& extension) noexcept {
                            return std::string { extension.extensionName };
                        }) |
                        std::ranges::to<std::vector>();
@@ -185,9 +184,10 @@ namespace stormkit::gpu {
                                      .setPEnabledExtensionNames(instance_extensions)
                                      .setPEnabledLayerNames(validation_layers);
 
-        return vkCreate<vk::raii::Instance>(m_vk_context, create_info)
+        return m_vk_context->createInstance(create_info)
             .transform(core::monadic::set(m_vk_instance))
-            .transform([this]() noexcept { VULKAN_HPP_DEFAULT_DISPATCHER.init(*m_vk_instance.get()); });
+            .transform(
+                [this]() noexcept { VULKAN_HPP_DEFAULT_DISPATCHER.init(*m_vk_instance.get()); });
     }
 
     /////////////////////////////////////
@@ -211,21 +211,19 @@ namespace stormkit::gpu {
                     std::bit_cast<decltype(vk::DebugUtilsMessengerCreateInfoEXT::pfnUserCallback)>(
                         &debugCallback));
 
-        return vkCreate<vk::raii::DebugUtilsMessengerEXT>(m_vk_instance, create_info)
+        return m_vk_instance->createDebugUtilsMessengerEXT(create_info)
             .transform(core::monadic::set(m_vk_messenger));
     }
 
     /////////////////////////////////////
     /////////////////////////////////////
     auto Instance::doRetrievePhysicalDevices() noexcept -> VulkanExpected<void> {
-        return vkCall(*m_vk_instance, &vk::raii::Instance::enumeratePhysicalDevices)
-            .transform([this](auto&& physical_devices) {
-                m_physical_devices =
-                    std::forward<decltype(physical_devices)>(physical_devices) |
-                    std::views::transform([this](auto&& physical_device) {
-                        return PhysicalDevice { std::move(physical_device), *this };
-                    }) |
-                    std::ranges::to<std::vector>();
-            });
+        return m_vk_instance->enumeratePhysicalDevices().transform([this](auto&& physical_devices) {
+            m_physical_devices = std::forward<decltype(physical_devices)>(physical_devices) |
+                                 std::views::transform([this](auto&& physical_device) {
+                                     return PhysicalDevice { std::move(physical_device), *this };
+                                 }) |
+                                 std::ranges::to<std::vector>();
+        });
     }
 } // namespace stormkit::gpu
diff --git a/src/Gpu/Execution/Pipeline.cpp b/src/Gpu/Execution/Pipeline.cpp
index d13282a6..294f8114 100644
--- a/src/Gpu/Execution/Pipeline.cpp
+++ b/src/Gpu/Execution/Pipeline.cpp
@@ -17,11 +17,10 @@ import :Execution.RasterPipelineState;
 namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
-    auto Pipeline::doInitRasterPipeline(
-        const PipelineLayout                             & layout,
-        const RenderPass                                 & render_pass,
-        std::optional<core::NakedRef<const PipelineCache>> pipeline_cache) noexcept
-        -> VulkanExpected<void> {
+    auto Pipeline::doInitRasterPipeline(const PipelineLayout& layout,
+                                        const RenderPass&     render_pass,
+                                        std::optional<core::NakedRef<const PipelineCache>>
+                                            pipeline_cache) noexcept -> VulkanExpected<void> {
         const auto& state = core::as<RasterPipelineState>(m_state);
 
         const auto binding_descriptions =
@@ -30,7 +29,8 @@ namespace stormkit::gpu {
                 return vk::VertexInputBindingDescription {}
                     .setBinding(binding_description.binding)
                     .setStride(binding_description.stride)
-                    .setInputRate(core::narrow<vk::VertexInputRate>(binding_description.input_rate));
+                    .setInputRate(
+                        core::narrow<vk::VertexInputRate>(binding_description.input_rate));
             }) |
             std::ranges::to<std::vector>();
 
@@ -51,7 +51,8 @@ namespace stormkit::gpu {
 
         const auto input_assembly =
             vk::PipelineInputAssemblyStateCreateInfo {}
-                .setTopology(core::narrow<vk::PrimitiveTopology>(state.input_assembly_state.topology))
+                .setTopology(
+                    core::narrow<vk::PrimitiveTopology>(state.input_assembly_state.topology))
                 .setPrimitiveRestartEnable(state.input_assembly_state.primitive_restart_enable);
 
         const auto viewports = state.viewport_state.viewports |
@@ -81,8 +82,10 @@ namespace stormkit::gpu {
             vk::PipelineRasterizationStateCreateInfo {}
                 .setDepthClampEnable(state.rasterization_state.depth_clamp_enable)
                 .setRasterizerDiscardEnable(state.rasterization_state.rasterizer_discard_enable)
-                .setPolygonMode(core::narrow<vk::PolygonMode>(state.rasterization_state.polygon_mode))
-                .setCullMode(core::narrow<vk::CullModeFlagBits>(state.rasterization_state.cull_mode))
+                .setPolygonMode(
+                    core::narrow<vk::PolygonMode>(state.rasterization_state.polygon_mode))
+                .setCullMode(
+                    core::narrow<vk::CullModeFlagBits>(state.rasterization_state.cull_mode))
                 .setFrontFace(core::narrow<vk::FrontFace>(state.rasterization_state.front_face))
                 .setLineWidth(state.rasterization_state.line_width);
 
@@ -122,22 +125,23 @@ namespace stormkit::gpu {
                                      state.color_blend_state.blend_constants[2],
                                      state.color_blend_state.blend_constants[3] });
 
-        const auto states =
-            state.dynamic_state.dynamics |
-            std::views::transform([](auto&& s) noexcept { return core::narrow<vk::DynamicState>(s); }) |
-            std::ranges::to<std::vector>();
+        const auto states = state.dynamic_state.dynamics |
+                            std::views::transform([](auto&& s) noexcept {
+                                return core::narrow<vk::DynamicState>(s);
+                            }) |
+                            std::ranges::to<std::vector>();
 
         const auto dynamic_state = vk::PipelineDynamicStateCreateInfo {}.setDynamicStates(states);
 
-        const auto shaders = state.shader_state.shaders |
-                             std::views::transform([](auto&& shader) noexcept {
-                                 static auto NAME = "main";
-                                 return vk::PipelineShaderStageCreateInfo {}
-                                     .setStage(core::narrow<vk::ShaderStageFlagBits>(shader->type()))
-                                     .setModule(toVkHandle()(shader))
-                                     .setPName(NAME);
-                             }) |
-                             std::ranges::to<std::vector>();
+        const auto shaders =
+            state.shader_state.shaders | std::views::transform([](auto&& shader) noexcept {
+                static auto NAME = "main";
+                return vk::PipelineShaderStageCreateInfo {}
+                    .setStage(core::narrow<vk::ShaderStageFlagBits>(shader->type()))
+                    .setModule(toVkHandle()(shader))
+                    .setPName(NAME);
+            }) |
+            std::ranges::to<std::vector>();
 
         const auto depth_stencil =
             vk::PipelineDepthStencilStateCreateInfo {}
@@ -170,13 +174,14 @@ namespace stormkit::gpu {
 
         const auto vk_pipeline_cache =
             core::either(pipeline_cache,
-                         core::monadic::map(toRaiiVkHandle(),
-                                                            core::monadic::init<OptCache>()),
+                         core::monadic::map(toRaiiVkHandle(), core::monadic::init<OptCache>()),
                          core::monadic::init<OptCache>(nullptr));
 
-        return vkCreate<vk::raii::Pipeline>(toRaiiVkHandle()(device()),
-                                            vk_pipeline_cache,
-                                            create_info)
-            .transform(core::monadic::set(m_vk_pipeline));
+        return device()
+            .vkHandle()
+            .createGraphicsPipelines(vk_pipeline_cache, create_info)
+            .transform([this](auto&& pipelines) noexcept {
+                m_vk_pipeline = std::move(pipelines.front());
+            });
     }
 } // namespace stormkit::gpu
diff --git a/src/Gpu/Execution/PipelineCache.cpp b/src/Gpu/Execution/PipelineCache.cpp
index dac44502..a2066538 100644
--- a/src/Gpu/Execution/PipelineCache.cpp
+++ b/src/Gpu/Execution/PipelineCache.cpp
@@ -34,9 +34,9 @@ namespace stormkit::gpu {
         std::ranges::copy(physical_device_infos.pipeline_cache_uuid,
                           std::ranges::begin(m_serialized.uuid.value));
 
-        const auto create_info = vk::PipelineCacheCreateInfo {};
-
-        return vkCreate<vk::raii::PipelineCache>(this->device().vkHandle(), create_info)
+        return this->device()
+            .vkHandle()
+            .createPipelineCache({})
             .transform(core::monadic::set(m_vk_pipeline_cache))
             .transform([this] noexcept -> void {
                 ilog("Created new pipeline cache at {}", m_path.string());
@@ -97,7 +97,9 @@ namespace stormkit::gpu {
 
         const auto create_info = vk::PipelineCacheCreateInfo {}.setInitialData<core::Byte>(data);
 
-        return vkCreate<vk::raii::PipelineCache>(this->device().vkHandle(), create_info)
+        return this->device()
+            .vkHandle()
+            .createPipelineCache(create_info)
             .transform(core::monadic::set(m_vk_pipeline_cache))
             .transform([this]() noexcept -> void {
                 ilog("Loading pipeline cache {}", m_path.string());
@@ -108,24 +110,21 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     /////////////////////////////////////
     auto PipelineCache::saveCache() -> void {
-        vkCall(*m_vk_pipeline_cache, &vk::raii::PipelineCache::getData)
-            .transform([this](auto&& data) noexcept {
-                m_serialized.guard.data_size = std::size(data);
-                m_serialized.guard.data_hash = 0u;
-
-                for (auto v : data) core::hashCombine(m_serialized.guard.data_hash, v);
-
-                auto stream = std::ofstream { m_path.string(), std::ios::binary | std::ios::trunc };
-                core::write(stream, core::asByteView(m_serialized.guard));
-
-                core::write(stream, core::asByteView(m_serialized.infos));
-                core::write(stream, core::asByteView(m_serialized.uuid.value));
-                core::write(stream, core::asByteView(data));
-                ilog("Saving pipeline cache at {}", m_path.string());
-            })
-            .transform_error([this](auto&& error) noexcept {
-                ilog("Failed to save pipeline cache at {}, reason: {}", m_path.string(), error);
-                return error;
-            });
+        auto data                    = m_vk_pipeline_cache->getData();
+        m_serialized.guard.data_size = std::size(data);
+        m_serialized.guard.data_hash = 0u;
+
+        for (auto v : data) core::hashCombine(m_serialized.guard.data_hash, v);
+
+        auto stream = std::ofstream { m_path.string(), std::ios::binary | std::ios::trunc };
+
+        core::write(stream, core::asByteView(m_serialized.guard));
+
+        core::write(stream, core::asByteView(m_serialized.infos));
+        core::write(stream, core::asByteView(m_serialized.uuid.value));
+        core::write(stream, core::asByteView(data));
+        ilog("Saving pipeline cache at {}", m_path.string());
+        // elog("Failed to save pipeline cache at {}, reason: {}", m_path.string(), error);
+        // return error;
     }
 } // namespace stormkit::gpu
diff --git a/src/Gpu/Execution/RenderPass.cpp b/src/Gpu/Execution/RenderPass.cpp
index cd56a0df..95c34c2a 100644
--- a/src/Gpu/Execution/RenderPass.cpp
+++ b/src/Gpu/Execution/RenderPass.cpp
@@ -57,7 +57,8 @@ namespace stormkit::gpu {
 
         for (const auto& subpass : m_description.subpasses) {
             auto& color_attachment_ref = color_attachment_refs.emplace_back(
-                subpass.color_attachment_refs | std::views::transform(monadic::vkRef()) | std::ranges::to<std::vector>());
+                subpass.color_attachment_refs | std::views::transform(monadic::vkRef()) |
+                std::ranges::to<std::vector>());
             auto& resolve_attachment_ref = resolve_attachment_refs.emplace_back(
                 subpass.resolve_attachment_refs | std::views::transform(monadic::vkRef()) |
                 std::ranges::to<std::vector>());
@@ -91,7 +92,9 @@ namespace stormkit::gpu {
                                      .setSubpasses(subpasses)
                                      .setDependencies(subpasses_deps);
 
-        return vkCreate<vk::raii::RenderPass>(toRaiiVkHandle()(device()), create_info)
+        return device()
+            .vkHandle()
+            .createRenderPass(create_info)
             .transform(core::monadic::set(m_vk_render_pass));
     }
 
diff --git a/src/Gpu/Resource/Buffer.cpp b/src/Gpu/Resource/Buffer.cpp
index f396c6cb..f85b1e53 100644
--- a/src/Gpu/Resource/Buffer.cpp
+++ b/src/Gpu/Resource/Buffer.cpp
@@ -19,12 +19,11 @@ namespace stormkit::gpu {
     Buffer::Buffer(const Device& device, const CreateInfo& info, bool persistently_mapped, Tag)
         : DeviceObject { device }, m_usages { info.usages }, m_size { info.size },
           m_is_persistently_mapped { persistently_mapped } {
-        const auto create_info = vk::BufferCreateInfo {}
-                                     .setSize(m_size)
-                                     .setUsage(core::narrow<vk::BufferUsageFlagBits>(m_usages))
-                                     .setSharingMode(vk::SharingMode::eExclusive);
-
-        vkCreate<vk::raii::Buffer>(this->device().vkHandle(), create_info)
+        this->device()
+            .vkHandle()
+            .createBuffer({ .size        = m_size,
+                            .usage       = core::narrow<vk::BufferUsageFlagBits>(m_usages),
+                            .sharingMode = vk::SharingMode::eExclusive })
             .transform(core::monadic::set(m_vk_buffer))
             .transform([this, &info]() noexcept -> VulkanExpected<void> {
                 const auto requirements = m_vk_buffer->getMemoryRequirements();
@@ -34,12 +33,14 @@ namespace stormkit::gpu {
 
                 auto&& allocator = this->device().vmaAllocator();
 
-                try {
-                    m_vma_allocation = allocator.allocateMemoryUnique(requirements, allocate_info);
-                    allocator.bindBufferMemory(*m_vma_allocation, *m_vk_buffer.get());
-                } catch (const vk::SystemError& err) {
-                    return std::unexpected { core::narrow<vk::Result>(err.code().value()) };
-                }
+                auto&& [error, m_vma_allocation] =
+                    allocator.allocateMemoryUnique(requirements, allocate_info);
+                if (error != vk::Result::eSuccess)
+                    return std::unexpected { core::narrow<vk::Result>(error) };
+
+                error = allocator.bindBufferMemory(*m_vma_allocation, *m_vk_buffer.get());
+                if (error != vk::Result::eSuccess)
+                    return std::unexpected { core::narrow<vk::Result>(error) };
 
                 if (m_is_persistently_mapped) [[maybe_unused]]
                     auto _ = map(0u);
@@ -53,7 +54,7 @@ namespace stormkit::gpu {
     /////////////////////////////////////
     auto Buffer::findMemoryType(core::UInt                                     type_filter,
                                 vk::MemoryPropertyFlags                        properties,
-                                const vk::PhysicalDeviceMemoryProperties     & mem_properties,
+                                const vk::PhysicalDeviceMemoryProperties&      mem_properties,
                                 [[maybe_unused]] const vk::MemoryRequirements& mem_requirements)
         -> core::UInt {
         for (auto i : core::range(mem_properties.memoryTypeCount)) {
diff --git a/src/Log/FileLogger.cpp b/src/Log/FileLogger.cpp
index 4e6ce8f4..51576801 100644
--- a/src/Log/FileLogger.cpp
+++ b/src/Log/FileLogger.cpp
@@ -12,7 +12,9 @@ import :FileLogger;
 
 using namespace std::literals;
 
-constexpr auto LOG_FILE_NAME = "log.txt";
+namespace {
+    constexpr auto LOG_FILE_NAME = "log.txt";
+}
 
 namespace stormkit::log {
     ////////////////////////////////////////
@@ -30,9 +32,9 @@ namespace stormkit::log {
 
     ////////////////////////////////////////
     ////////////////////////////////////////
-    FileLogger::FileLogger(LogClock::time_point start,
+    FileLogger::FileLogger(LogClock::time_point  start,
                            std::filesystem::path path,
-                           Severity log_level)
+                           Severity              log_level)
         : Logger { std::move(start), log_level }, m_base_path { std::move(path) } {
         if (not std::filesystem::exists(m_base_path))
             std::filesystem::create_directory(m_base_path);
@@ -63,9 +65,9 @@ namespace stormkit::log {
 
     ////////////////////////////////////////
     ////////////////////////////////////////
-    auto FileLogger::write([[maybe_unused]] Severity severity,
+    auto FileLogger::write([[maybe_unused]] Severity      severity,
                            [[maybe_unused]] const Module& m,
-                           [[maybe_unused]] const char *string) -> void {
+                           [[maybe_unused]] const char   *string) -> void {
         const auto now = LogClock::now();
         const auto time =
             std::chrono::duration_cast<std::chrono::seconds>(now - m_start_time).count();
diff --git a/src/Log/Logger.cpp b/src/Log/Logger.cpp
index ae60be72..6c31b7a2 100644
--- a/src/Log/Logger.cpp
+++ b/src/Log/Logger.cpp
@@ -19,10 +19,9 @@ namespace stormkit::log {
 #else
         constexpr auto DEFAULT_SEVERITY = Severity::Info | Severity::Error | Severity::Fatal;
 #endif
+        Logger *logger = nullptr;
     } // namespace
 
-    static Logger *logger = nullptr;
-
     /////////////////////////////////////
     /////////////////////////////////////
     Logger::Logger(LogClock::time_point start_time) noexcept
diff --git a/src/Main/iOS/Main.mm b/src/Main/iOS/Main-iOS.mm
similarity index 95%
rename from src/Main/iOS/Main.mm
rename to src/Main/iOS/Main-iOS.mm
index 15729cfe..09ba4ef6 100644
--- a/src/Main/iOS/Main.mm
+++ b/src/Main/iOS/Main-iOS.mm
@@ -1,7 +1,7 @@
-#import <UIKit/UIKit.h>
-
-auto main(int argc, char *argv[]) -> int {
-    @autoreleasepool {
-        return UIApplicationMain(argc, argv, nil, @"AppDelegate");
-    }
-}
+#import <UIKit/UIKit.h>
+
+auto main(int argc, char *argv[]) -> int {
+    @autoreleasepool {
+        return UIApplicationMain(argc, argv, nil, @"AppDelegate");
+    }
+}
diff --git a/src/Main/linux/Main.cpp b/src/Main/linux/Main-linux.cpp
similarity index 96%
rename from src/Main/linux/Main.cpp
rename to src/Main/linux/Main-linux.cpp
index 0225a516..c6ead517 100644
--- a/src/Main/linux/Main.cpp
+++ b/src/Main/linux/Main-linux.cpp
@@ -1,16 +1,16 @@
-// Copyright (C) 2023 Arthur LAURENT <arthur.laurent4@gmail.com>
-// This file is subject to the license terms in the LICENSE file
-// found in the top-level of this distribution
-
-import std;
-import stormkit.Core;
-
-extern auto userMain(std::span<const std::string_view>) -> int;
-
-auto main(int argc, char **argv) -> int {
-    auto args = std::vector<std::string_view> {};
-
-    for (auto i : stormkit::core::range(argc)) args.emplace_back(argv[i]);
-
-    return userMain(args);
+// Copyright (C) 2023 Arthur LAURENT <arthur.laurent4@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level of this distribution
+
+import std;
+import stormkit.Core;
+
+extern auto userMain(std::span<const std::string_view>) -> int;
+
+auto main(int argc, char **argv) -> int {
+    auto args = std::vector<std::string_view> {};
+
+    for (auto i : stormkit::core::range(argc)) args.emplace_back(argv[i]);
+
+    return userMain(args);
 }
\ No newline at end of file
diff --git a/src/Main/macOS/Main.mm b/src/Main/macOS/Main-macOS.mm
similarity index 96%
rename from src/Main/macOS/Main.mm
rename to src/Main/macOS/Main-macOS.mm
index 610eb3e1..426253c7 100644
--- a/src/Main/macOS/Main.mm
+++ b/src/Main/macOS/Main-macOS.mm
@@ -1,19 +1,19 @@
-#import <Foundation/NSBundle.h>
-#import <Foundation/NSFileManager.h>
-
-#include <string_view>
-#include <vector>
-#include <span>
-
-extern auto userMain(std::span<const std::string_view>) -> int;
-
-auto main(const int argc, const char **argv) -> int {
-    [[NSFileManager defaultManager]
-        changeCurrentDirectoryPath:[[NSBundle mainBundle] resourcePath]];
-
-    auto args = std::vector<std::string_view> {};
-
-    for (auto i = 0u; i < argc; ++i) args.emplace_back(argv[i]);
-
-    return userMain(args);
-}
+#import <Foundation/NSBundle.h>
+#import <Foundation/NSFileManager.h>
+
+#include <string_view>
+#include <vector>
+#include <span>
+
+extern auto userMain(std::span<const std::string_view>) -> int;
+
+auto main(const int argc, const char **argv) -> int {
+    [[NSFileManager defaultManager]
+        changeCurrentDirectoryPath:[[NSBundle mainBundle] resourcePath]];
+
+    auto args = std::vector<std::string_view> {};
+
+    for (auto i = 0u; i < argc; ++i) args.emplace_back(argv[i]);
+
+    return userMain(args);
+}
diff --git a/src/Main/win32/Main.cpp b/src/Main/win32/Main-win.cpp
similarity index 64%
rename from src/Main/win32/Main.cpp
rename to src/Main/win32/Main-win.cpp
index ad596e94..2e616627 100644
--- a/src/Main/win32/Main.cpp
+++ b/src/Main/win32/Main-win.cpp
@@ -1,44 +1,59 @@
-// Copyright (C) 2023 Arthur LAURENT <arthur.laurent4@gmail.com>
-// This file is subject to the license terms in the LICENSE file
-// found in the top-level of this distribution
-
-#include <windows.h>
-#undef __nullnullterminated
-
-#include <cstdio>
-#include <cstdlib>
-
-import std;
-
-#include <stormkit/Core/PlatformMacro.hpp>
-
-import stormkit.Core;
-
-namespace {
-    constexpr auto BUF_SIZE = 1024;
-}
-
-extern auto userMain(std::span<const std::string_view>) -> int;
-
-auto __stdcall main(int argc, char **argv) -> int {
-    std::locale::global(std::locale { "" });
-    SetConsoleOutputCP(CP_UTF8);
-    SetConsoleCP(CP_UTF8);
-    setvbuf(stderr,
-            nullptr,
-            _IOFBF,
-            BUF_SIZE); // on Windows 10+ we need buffering or console will get 1
-                       // byte at a time (screwing up utf-8 encoding)
-    setvbuf(stdout, nullptr, _IOFBF, BUF_SIZE);
-
-    auto args = std::vector<std::string_view> {};
-    args.reserve(argc);
-
-    for (auto &&i : stormkit::core::range(argc)) args.emplace_back(argv[i]);
-
-    return userMain(args);
-}
-
-auto __stdcall WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) -> int {
-    return main(__argc, __argv);
-}
+// Copyright (C) 2023 Arthur LAURENT <arthur.laurent4@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level of this distribution
+
+#include <windows.h>
+#undef __nullnullterminated
+
+#include <cstdio>
+#include <cstdlib>
+
+import std;
+
+import stormkit.Core;
+
+namespace {
+    constexpr auto BUF_SIZE = 1024;
+}
+
+extern auto userMain(std::span<const std::string_view>) -> int;
+
+auto __stdcall main(int argc, char **argv) -> int {
+    std::locale::global(std::locale { "" });
+    SetConsoleOutputCP(CP_UTF8);
+    SetConsoleCP(CP_UTF8);
+    setvbuf(stderr,
+            nullptr,
+            _IOFBF,
+            BUF_SIZE); // on Windows 10+ we need buffering or console will get 1
+                       // byte at a time (screwing up utf-8 encoding)
+    setvbuf(stdout, nullptr, _IOFBF, BUF_SIZE);
+
+    auto args = std::vector<std::string_view> {};
+    args.reserve(argc);
+
+    for (auto &&i : stormkit::core::range(argc)) args.emplace_back(argv[i]);
+
+    return userMain(args);
+}
+
+auto __stdcall WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) -> int {
+    const auto argc = __argc;
+    const auto argv = __argv;
+    std::locale::global(std::locale { "" });
+    SetConsoleOutputCP(CP_UTF8);
+    SetConsoleCP(CP_UTF8);
+    setvbuf(stderr,
+            nullptr,
+            _IOFBF,
+            BUF_SIZE); // on Windows 10+ we need buffering or console will get 1
+                       // byte at a time (screwing up utf-8 encoding)
+    setvbuf(stdout, nullptr, _IOFBF, BUF_SIZE);
+
+    auto args = std::vector<std::string_view> {};
+    args.reserve(argc);
+
+    for (auto &&i : stormkit::core::range(argc)) args.emplace_back(argv[i]);
+
+    return userMain(args);
+}
diff --git a/xmake.lua b/xmake.lua
index 8e9ef5ce..debc6ee7 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -58,6 +58,7 @@ modules = {
     deps = { "stormkit-core" },
     custom = function()
         add_cxflags("-Wno-main")
+        set_strip("debug")
     end
   },
   wsi = {
@@ -121,13 +122,13 @@ modules = {
   gpu = {
     modulename = "Gpu",
     has_headers = true,
-    public_packages = { "frozen", "vulkan-headers", "vulkan-memory-allocator", "vulkan-memory-allocator-hpp" },
+    public_packages = { "vulkan-headers", "vulkan-memory-allocator", "vulkan-memory-allocator-hpp" },
     public_deps = { "stormkit-core", "stormkit-log", "stormkit-wsi", "stormkit-image" },
     packages = is_plat("linux") and {
       "libxcb",
       "wayland",
     } or nil,
-    defines = {
+    public_defines = {
       "VK_NO_PROTOTYPES",
       "VMA_DYNAMIC_VULKAN_FUNCTIONS=1",
       "VMA_STATIC_VULKAN_FUNCTIONS=0",
@@ -135,7 +136,8 @@ modules = {
       "VULKAN_HPP_NO_STRUCT_CONSTRUCTORS",
       "VULKAN_HPP_NO_UNION_CONSTRUCTORS",
       "VULKAN_HPP_STORAGE_SHARED",
-      -- "VULKAN_HPP_NO_EXCEPTIONS", uncomment when vk::raii is supported without exceptions
+      "VULKAN_HPP_NO_EXCEPTIONS",
+      "VULKAN_HPP_NO_CONSTRUCTORS"
     },
     custom = function()
       if is_plat("linux") then
@@ -148,48 +150,16 @@ modules = {
   },
 }
 
-package("vulkan-memory-allocator", function()
-  set_kind("library", { headeronly = true })
-  set_homepage("https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/")
-  set_description("Easy to integrate Vulkan memory allocation library.")
-  set_license("MIT")
-
-  add_urls(
-    "https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/archive/refs/tags/$(version).tar.gz",
-    "https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git"
-  )
-
-  on_install("windows", "linux", "mingw", "macosx", "iphoneos", "android", function(package)
-    os.cp("include/vk_mem_alloc.h", package:installdir("include"))
-  end)
-end)
-
-package("vulkan-memory-allocator-hpp", function()
-  set_kind("library", { headeronly = true })
-  set_homepage("https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/")
-  set_description("C++ bindings for VulkanMemoryAllocator.")
-  set_license("CC0")
-
-  add_urls(
-    "https://github.com/YaaZ/VulkanMemoryAllocator-Hpp/archive/refs/tags/$(version).tar.gz",
-    "https://github.com/YaaZ/VulkanMemoryAllocator-Hpp.git"
-  )
-
-  on_install("windows|x86", "windows|x64", "linux", "macosx", "mingw", "android", "iphoneos", function(package)
-    os.cp("include", package:installdir())
-  end)
-end)
-
 package("frozen", function()
   set_homepage("https://github.com/serge-sans-paille/frozen")
   set_description("A header-only, constexpr alternative to gperf for C++14 users")
   set_license("Apache-2.0")
 
-  -- set_urls("https://github.com/Arthapz/frozen.git")
-  set_sourcedir("../frozen")
+  set_urls("https://github.com/Arthapz/frozen.git")
+  -- set_sourcedir("../frozen")
 
   on_install(function(package)
-    import("package.tools.xmake").install(package, { enable_module = true, enable_std_import = true })
+    import("package.tools.xmake").install(package, { enable_module = true, enable_std_import = true, enable_tests = false, enable_benchmark = false })
   end)
 end)
 
@@ -325,7 +295,7 @@ if is_plat("windows") then
   add_defines("WIN32_LEAN_AND_MEAN")
   add_defines("__SPECSTRINGS_STRICT_LEVEL=0")
   add_defines("NOMINMAX")
-  add_cxflags("-fansi-escape-codes")
+  add_cxflags("clang::-fansi-escape-codes")
 end
 
 add_cxxflags("clang::-fexperimental-library", { force = true })
@@ -339,9 +309,9 @@ if get_config("sanitizers") then
 end
 
 if has_config("enable_gpu") then
-  add_requires("vulkan-headers main", { system = false })
-  add_requires("vulkan-memory-allocator master", { system = false })
-  add_requires("vulkan-memory-allocator-hpp master", { system = false })
+  add_requireconfs("vulkan-headers", { override = true, system = false })
+  add_requireconfs("vulkan-memory-allocator", { override = true, version = "master", system = false })
+  add_requireconfs("vulkan-memory-allocator-hpp", { override = true, version = "master", system = false, configs = { use_vulkanheaders = true }})
 end
 
 -- add_defines("FROZEN_DONT_INCLUDE_STL", "ANKERL_UNORDERED_DENSE_USE_STD_IMPORT")
@@ -455,6 +425,10 @@ for name, module in pairs(modules) do
         add_defines(module.defines)
       end
 
+      if module.public_defines then
+        add_defines(module.public_defines, { public = true })
+      end
+
       if module.cxxflags then
         add_cxxflags(module.cxxflags)
         add_mxxflags(module.cxxflags)
@@ -480,7 +454,7 @@ for name, module in pairs(modules) do
         add_frameworks(module.frameworks, { public = is_kind("static") })
       end
       if is_mode("release") then
-          set_policy("build.optimization.lto", true)
+          -- set_policy("build.optimization.lto", true)
       end
     end)
   end
diff --git a/xmake/vmahpp.lua b/xmake/vmahpp.lua
new file mode 100644
index 00000000..0f4a5c28
--- /dev/null
+++ b/xmake/vmahpp.lua
@@ -0,0 +1,65 @@
+package("vulkan-memory-allocator-hpp")
+    set_kind("library")
+    set_homepage("https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/")
+    set_description("C++ bindings for VulkanMemoryAllocator.")
+    set_license("CC0")
+
+    add_urls("https://github.com/YaaZ/VulkanMemoryAllocator-Hpp/archive/refs/tags/$(version).tar.gz",
+             "https://github.com/YaaZ/VulkanMemoryAllocator-Hpp.git")
+    add_versions("v3.0.0", '2f062b1631af64519d09e7b319c2ba06d7de3c9c5589fb7109a3f4e341cee2b7')
+    add_versions("v3.0.1-1", '0e0c374751d5ca6123d0ae0df756693f0674412d7c758ec4a39a5a9dcc412911')
+    add_versions("v3.0.1-3", '66a3d4be3bc1404c844b5a36aadeb6b366878e7cf1efe899eb0a0095f3871aae')
+
+    add_configs("modules", {description = "Build with C++20 modules support.", default = false, type = "boolean"})
+    add_configs("use_vulkanheaders", {description = "Use vulkan-headers package instead of vulkan-hpp.", default = false, type = "boolean"})
+
+    add_deps("vulkan-memory-allocator master")
+
+    on_install("windows|x86", "windows|x64", "linux", "macosx", "mingw", "android", "iphoneos", function (package)
+        if not package:config("modules") then
+            if package:config("use_vulkanheaders") then
+                if package:gitref() or package:version():ge("3.0.1") then
+                    package:add("deps", "vulkan-headers >= 1.3.234")
+                else
+                    package:add("deps", "vulkan-headers < 1.3.234")
+                end
+            else
+                if package:gitref() or package:version():ge("3.0.1") then
+                    package:add("deps", "vulkan-hpp >= 1.3.234")
+                else
+                    package:add("deps", "vulkan-hpp < 1.3.234")
+                end
+            end
+            os.cp("include", package:installdir())
+        else
+            local vulkan_dep
+            if package:config("use_vulkanheaders") then
+                vulkan_dep = "vulkan-headers"
+                package:add("deps", "vulkan-headers >= 1.3.275")
+            else
+                vulkan_dep = "vulkan-hpp"
+                package:add("deps", "vulkan-hpp >= 1.3.275")
+            end
+            io.writefile("xmake.lua", format([[
+                add_requires("vulkan-memory-allocator master", "%s >= 1.3.275")
+                target("vulkan-memory-allocator-hpp")
+                    set_kind("static")
+                    set_languages("c++20")
+                    add_headerfiles("include/(**.hpp)")
+                    add_includedirs("include")
+                    add_files("src/*.cppm", {public = true})
+                    add_packages("vulkan-memory-allocator", "%s")
+            ]], vulkan_dep, vulkan_dep))
+            local configs = {}
+            import("package.tools.xmake").install(package, configs)
+        end
+    end)
+
+    on_test(function (package)
+        assert(package:check_cxxsnippets({test = [[
+            void test() {
+                int version = VMA_VULKAN_VERSION;
+            }
+        ]]}, {includes = "vk_mem_alloc.hpp", configs = {languages = "c++14"} }))
+    end)
+package_end()