diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7176e8c..521e781 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -283,31 +283,65 @@ endif()
 
 # Build Vulkan-Hpp as a module
 if( VULKAN_HPP_ENABLE_CPP20_MODULES )
-	if( VULKAN_HPP_ENABLE_STD_MODULE AND CMAKE_VERSION VERSION_LESS "3.30" )
+	if ( VULKAN_HPP_ENABLE_STD_MODULE AND CMAKE_VERSION VERSION_LESS "3.30" )
 		message( FATAL_ERROR "Vulkan-Hpp: C++20 modules with import std require CMake 3.30 or later" )
 	elseif ( CMAKE_VERSION VERSION_LESS "3.28" )
 		message( FATAL_ERROR "Vulkan-Hpp: C++20 modules require CMake 3.28 or later" )
 	endif()
 
-	# create a target to provide VulkanHpp as C++20 module
-	add_library( VulkanHppModule )
-	add_library( Vulkan::HppModule ALIAS VulkanHppModule )
-	# Clang 16's module support can be broken with extensions enabled
-	if ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "16.0" )
-		set_target_properties( VulkanHppModule PROPERTIES CXX_EXTENSIONS OFF )
-	endif()
-	if( VULKAN_HPP_ENABLE_STD_MODULE )
-		target_compile_features( VulkanHppModule PUBLIC cxx_std_23 )
-		set_target_properties( VulkanHppModule PROPERTIES CXX_MODULE_STD ON )
-	else()
-		target_compile_features( VulkanHppModule PUBLIC cxx_std_20 )
-	endif()
-	target_sources( VulkanHppModule PUBLIC
-		FILE_SET vulkan_module_file
-		BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}
-		TYPE CXX_MODULES
-		FILES vulkan/vulkan.cppm )
-	target_link_libraries( VulkanHppModule PUBLIC Vulkan::Hpp )
+	function ( vulkan_hpp__setup_module )
+		set( options )
+		set( oneValueArgs NAME FILE_SET_NAME )
+		set( multiValueArgs FILE_SET ALIAS )
+		cmake_parse_arguments( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
+
+		if ( NOT TARGET_NAME )
+			message( FATAL_ERROR "NAME must be defined in vulkan_hpp__setup_module" )
+		endif()
+
+		add_library( ${TARGET_NAME} )
+		foreach( TARGET_ALIAS_NAME IN LISTS TARGET_ALIAS )
+			add_library(${TARGET_ALIAS_NAME} ALIAS ${TARGET_NAME})
+		endforeach()
+
+		# Clang 16's module support can be broken with extensions enabled
+		if ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "16.0" )
+			set_target_properties( ${TARGET_NAME} PROPERTIES CXX_EXTENSIONS OFF )
+		endif()
+
+		if ( VULKAN_HPP_ENABLE_STD_MODULE )
+			target_compile_features( ${TARGET_NAME} PUBLIC cxx_std_23 )
+			set_target_properties( ${TARGET_NAME} PROPERTIES CXX_MODULE_STD ON )
+		else()
+			target_compile_features( ${TARGET_NAME} PUBLIC cxx_std_20 )
+		endif()
+
+		if ( NOT TARGET_FILE_SET )
+			message( FATAL_ERROR "FILE_SET must be defined in vulkan_hpp__setup_module" )
+		endif()
+
+		list(LENGTH TARGET_FILE_SET TARGET_FILE_SET_LENGTH)
+		if ( TARGET_FILE_SET_LENGTH LESS 1 )
+			message(FATAL_ERROR "FILE_SET in vulkan_hpp__setup_module must at least one source file")
+		endif()
+
+		target_sources( ${TARGET_NAME} PUBLIC
+			FILE_SET ${TARGET_FILE_SET_NAME}
+			BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}
+			TYPE CXX_MODULES
+			FILES ${TARGET_FILE_SET} )
+		target_link_libraries( ${TARGET_NAME} PUBLIC Vulkan::Hpp )
+	endfunction()
+
+	# create targets providing VulkanHpp and VulkanVideoHpp as C++20 modules
+	vulkan_hpp__setup_module( NAME VulkanHppModule
+		FILE_SET_NAME vulkan_module_file
+		FILE_SET vulkan/vulkan.cppm
+		ALIAS Vulkan::HppModule )
+	vulkan_hpp__setup_module( NAME VulkanVideoHppModule
+		FILE_SET_NAME vulkan_video_module_file
+		FILE_SET vulkan/vulkan_video.cppm
+		ALIAS Vulkan::VideoHppModule )
 endif()
 
 function( vulkan_hpp__setup_platform )
@@ -569,6 +603,7 @@ if( ${VULKAN_HPP_INSTALL} )
 		${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_to_string.hpp
 		${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_video.hpp
 		${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan.cppm
+		${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_video.cppm
 		${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan.hpp
 	)
 	install( FILES ${VK_GENERATED_VULKAN_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/vulkan )
diff --git a/VideoHppGenerator.cpp b/VideoHppGenerator.cpp
index 19c3365..2626f54 100644
--- a/VideoHppGenerator.cpp
+++ b/VideoHppGenerator.cpp
@@ -81,6 +81,42 @@ ${structs}
   writeToFile( str, video_hpp );
 }
 
+void VideoHppGenerator::generateCppModuleFile() const
+{
+  std::string const vulkan_video_cppm = std::string( BASE_PATH ) + "/vulkan/vulkan_video.cppm";
+  messager.message( "VideoHppGenerator: Generating " + vulkan_video_cppm + " ...\n" );
+
+  std::string const videoCppmTemplate = R"(${copyrightMessage}
+
+// 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_macros.hpp>
+
+#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
+#define VULKAN_HPP_ENABLE_STD_MODULE
+#endif
+
+#include <vulkan/vulkan_video.hpp>
+
+export module vulkan_video_hpp;
+
+export namespace VULKAN_HPP_NAMESPACE
+{
+namespace VULKAN_HPP_VIDEO_NAMESPACE
+{
+${usings}
+}   // namespace VULKAN_HPP_VIDEO_NAMESPACE
+}   // namespace VULKAN_HPP_NAMESPACE
+)";
+
+  std::string str = replaceWithMap( videoCppmTemplate, { { "copyrightMessage", m_copyrightMessage }, { "usings", generateCppModuleUsings() } } );
+
+  writeToFile( str, vulkan_video_cppm );
+}
+
 void VideoHppGenerator::addImplicitlyRequiredTypes()
 {
   for ( auto & ext : m_extensions )
@@ -280,6 +316,37 @@ std::string VideoHppGenerator::generateEnums( RequireData const & requireData, s
   return str;
 }
 
+std::string VideoHppGenerator::generateCppModuleEnumUsings() const
+{
+  auto const usingTemplate = std::string{
+    R"(  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::${enumName};
+)"
+  };
+
+  const std::string enumsTemplate = R"(
+  //=============
+  //=== ENUMs ===
+  //=============
+
+${enums}
+)";
+
+  std::string enums;
+  for ( auto const & extension : m_extensions )
+  {
+    for ( auto const & type : extension.requireData.types )
+    {
+      auto enumIt = m_enums.find( type );
+      if ( enumIt != m_enums.end() )
+      {
+        enums += replaceWithMap( usingTemplate, { { "enumName", stripPrefix( enumIt->first, "StdVideo" ) } } );
+      }
+    }
+  }
+
+  return replaceWithMap( enumsTemplate, { { "enums", enums } } );
+}
+
 std::string VideoHppGenerator::generateStruct( std::pair<std::string, StructureData> const & structData ) const
 {
   static const std::string structureTemplate = R"(  struct ${structureType}
@@ -449,6 +516,42 @@ std::string VideoHppGenerator::generateStructs( RequireData const & requireData,
   return str;
 }
 
+std::string VideoHppGenerator::generateCppModuleStructUsings() const
+{
+  auto const usingTemplate = std::string{
+    R"(  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::${structName};
+)"
+  };
+
+  const std::string structsTemplate = R"(
+  //===============
+  //=== STRUCTS ===
+  //===============
+
+${structs}
+)";
+
+  std::string structs;
+  for ( auto const & extension : m_extensions )
+  {
+    for ( auto const & type : extension.requireData.types )
+    {
+      auto structIt = m_structs.find( type );
+      if ( structIt != m_structs.end() )
+      {
+        structs += replaceWithMap( usingTemplate, { { "structName", stripPrefix( structIt->first, "StdVideo" ) } } );
+      }
+    }
+  }
+
+  return replaceWithMap( structsTemplate, { { "structs", structs } } );
+}
+
+std::string VideoHppGenerator::generateCppModuleUsings() const
+{
+  return generateCppModuleEnumUsings() + generateCppModuleStructUsings();
+}
+
 bool VideoHppGenerator::isExtension( std::string const & name ) const
 {
   return std::ranges::any_of( m_extensions, [&name]( ExtensionData const & ed ) { return ed.name == name; } );
@@ -1059,6 +1162,7 @@ int main( int argc, char ** argv )
     VideoHppGenerator generator( doc );
 
     generator.generateHppFile();
+    generator.generateCppModuleFile();
 
 #if !defined( CLANG_FORMAT_EXECUTABLE )
     std::cout << "VideoHppGenerator: could not find clang-format. The generated files will not be formatted accordingly.\n";
diff --git a/VideoHppGenerator.hpp b/VideoHppGenerator.hpp
index bc31a57..51a9955 100644
--- a/VideoHppGenerator.hpp
+++ b/VideoHppGenerator.hpp
@@ -26,6 +26,7 @@ public:
   VideoHppGenerator( tinyxml2::XMLDocument const & document );
 
   void generateHppFile() const;
+  void generateCppModuleFile() const;
 
 private:
   struct ConstantData
@@ -108,6 +109,9 @@ private:
   std::string                                      generateStructMembers( std::pair<std::string, StructureData> const & structData ) const;
   std::string                                      generateStructs() const;
   std::string                                      generateStructs( RequireData const & requireData, std::string const & title ) const;
+  std::string                                      generateCppModuleEnumUsings() const;
+  std::string                                      generateCppModuleStructUsings() const;
+  std::string                                      generateCppModuleUsings() const;
   bool                                             isExtension( std::string const & name ) const;
   std::string                                      readComment( tinyxml2::XMLElement const * element ) const;
   void                                             readEnums( tinyxml2::XMLElement const * element );
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 61e593e..e9573c3 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -47,3 +47,6 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 	add_subdirectory( UniqueHandleDefaultArguments )
 endif()
 add_subdirectory( Video )
+if( VULKAN_HPP_ENABLE_CPP20_MODULES )
+	add_subdirectory( VideoCpp20Modules )
+endif()
diff --git a/tests/VideoCpp20Modules/CMakeLists.txt b/tests/VideoCpp20Modules/CMakeLists.txt
new file mode 100644
index 0000000..e766bb2
--- /dev/null
+++ b/tests/VideoCpp20Modules/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright(c) 2018, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+vulkan_hpp__setup_test( NAME VideoCpp20Modules CXX_STANDARD 20 LIBRARIES VulkanVideoHppModule NO_UTILS )
+set_target_properties( VideoCpp20Modules PROPERTIES CXX_SCAN_FOR_MODULES ON )
diff --git a/tests/VideoCpp20Modules/VideoCpp20Modules.cpp b/tests/VideoCpp20Modules/VideoCpp20Modules.cpp
new file mode 100644
index 0000000..edce6ff
--- /dev/null
+++ b/tests/VideoCpp20Modules/VideoCpp20Modules.cpp
@@ -0,0 +1,40 @@
+// Copyright(c) 2024, NVIDIA CORPORATION. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// VulkanHpp Samples : Video
+//                     Compile test on using vk::video
+
+#if defined( _MSC_VER )
+#  pragma warning( disable : 4101 )   // 'name': unreference local variable
+#elif defined( __clang__ )
+#  pragma clang diagnostic ignored "-Wunused-variable"
+#elif defined( __GNUC__ )
+#  pragma GCC diagnostic ignored "-Wunused-variable"
+#else
+// unknown compiler... just ignore the warnings for yourselves ;)
+#endif
+
+import vulkan_video_hpp;
+
+int main( int /*argc*/, char ** /*argv*/ )
+{
+  vk::video::H264ChromaFormatIdc x;
+  vk::video::H264ProfileIdc      y;
+
+#if ( 301 < VK_HEADER_VERSION )
+  vk::video::EncodeAV1DecoderModelInfo z;
+#endif
+
+  return 0;
+}
diff --git a/vulkan/vulkan_video.cppm b/vulkan/vulkan_video.cppm
new file mode 100644
index 0000000..cd9d1f1
--- /dev/null
+++ b/vulkan/vulkan_video.cppm
@@ -0,0 +1,157 @@
+// Copyright 2021-2025 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_macros.hpp>
+
+#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
+#  define VULKAN_HPP_ENABLE_STD_MODULE
+#endif
+
+#include <vulkan/vulkan_video.hpp>
+
+export module vulkan_video_hpp;
+
+export namespace VULKAN_HPP_NAMESPACE
+{
+  namespace VULKAN_HPP_VIDEO_NAMESPACE
+  {
+
+    //=============
+    //=== ENUMs ===
+    //=============
+
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType;
+
+    //===============
+    //=== STRUCTS ===
+    //===============
+
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags;
+
+  }  // namespace VULKAN_HPP_VIDEO_NAMESPACE
+}  // namespace VULKAN_HPP_NAMESPACE