Update for Vulkan-Docs 1.2.187v1.2.187

7 files changed, 329 insertions, 331 deletions

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 701052c..f18dce9 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -111,7 +111,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 186, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 187, "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@@ -5592,7 +5592,7 @@ namespace VULKAN_HPP_NAMESPACE
     ObjectDestroy( OwnerType                           owner,
                    Optional<const AllocationCallbacks> allocationCallbacks
                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                   Dispatch const &                    dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+                   Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
       : m_owner( owner )
       , m_allocationCallbacks( allocationCallbacks )
       , m_dispatch( &dispatch )
@@ -5630,7 +5630,7 @@ namespace VULKAN_HPP_NAMESPACE
     ObjectDestroy() = default;
 
     ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
-                   Dispatch const &                    dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+                   Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
       : m_allocationCallbacks( allocationCallbacks )
       , m_dispatch( &dispatch )
     {}
@@ -5661,7 +5661,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     ObjectFree( OwnerType                           owner,
                 Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+                Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
       : m_owner( owner )
       , m_allocationCallbacks( allocationCallbacks )
       , m_dispatch( &dispatch )
@@ -5697,7 +5697,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     ObjectRelease() = default;
 
-    ObjectRelease( OwnerType owner, Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+    ObjectRelease( OwnerType        owner,
+                   Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
       : m_owner( owner )
       , m_dispatch( &dispatch )
     {}
@@ -5728,7 +5729,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     PoolFree( OwnerType        owner,
               PoolType         pool,
-              Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+              Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
       : m_owner( owner )
       , m_pool( pool )
       , m_dispatch( &dispatch )
diff --git a/include/vulkan/vulkan_beta.h b/include/vulkan/vulkan_beta.h
index c615bb3..e2337ad 100644
--- a/include/vulkan/vulkan_beta.h
+++ b/include/vulkan/vulkan_beta.h
@@ -22,7 +22,7 @@ extern "C" {
 #define VK_KHR_video_queue 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR)
-#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION   1
+#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION   2
 #define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue"
 
 typedef enum VkQueryResultStatusKHR {
@@ -66,12 +66,12 @@ typedef enum VkVideoComponentBitDepthFlagBitsKHR {
 } VkVideoComponentBitDepthFlagBitsKHR;
 typedef VkFlags VkVideoComponentBitDepthFlagsKHR;
 
-typedef enum VkVideoCapabilitiesFlagBitsKHR {
-    VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
-    VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002,
-    VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoCapabilitiesFlagBitsKHR;
-typedef VkFlags VkVideoCapabilitiesFlagsKHR;
+typedef enum VkVideoCapabilityFlagBitsKHR {
+    VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
+    VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002,
+    VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoCapabilityFlagBitsKHR;
+typedef VkFlags VkVideoCapabilityFlagsKHR;
 
 typedef enum VkVideoSessionCreateFlagBitsKHR {
     VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0,
@@ -120,16 +120,16 @@ typedef struct VkVideoProfilesKHR {
 } VkVideoProfilesKHR;
 
 typedef struct VkVideoCapabilitiesKHR {
-    VkStructureType                sType;
-    void*                          pNext;
-    VkVideoCapabilitiesFlagsKHR    capabilityFlags;
-    VkDeviceSize                   minBitstreamBufferOffsetAlignment;
-    VkDeviceSize                   minBitstreamBufferSizeAlignment;
-    VkExtent2D                     videoPictureExtentGranularity;
-    VkExtent2D                     minExtent;
-    VkExtent2D                     maxExtent;
-    uint32_t                       maxReferencePicturesSlotsCount;
-    uint32_t                       maxReferencePicturesActiveCount;
+    VkStructureType              sType;
+    void*                        pNext;
+    VkVideoCapabilityFlagsKHR    capabilityFlags;
+    VkDeviceSize                 minBitstreamBufferOffsetAlignment;
+    VkDeviceSize                 minBitstreamBufferSizeAlignment;
+    VkExtent2D                   videoPictureExtentGranularity;
+    VkExtent2D                   minExtent;
+    VkExtent2D                   maxExtent;
+    uint32_t                     maxReferencePicturesSlotsCount;
+    uint32_t                     maxReferencePicturesActiveCount;
 } VkVideoCapabilitiesKHR;
 
 typedef struct VkPhysicalDeviceVideoFormatInfoKHR {
@@ -433,10 +433,10 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
 #define VK_EXT_video_encode_h264 1
 #include "vk_video/vulkan_video_codec_h264std.h"
 #include "vk_video/vulkan_video_codec_h264std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 1
+#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 2
 #define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
 
-typedef enum VkVideoEncodeH264CapabilitiesFlagBitsEXT {
+typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
     VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00000001,
     VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00000002,
     VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = 0x00000004,
@@ -448,9 +448,9 @@ typedef enum VkVideoEncodeH264CapabilitiesFlagBitsEXT {
     VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100,
     VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200,
     VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400,
-    VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264CapabilitiesFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264CapabilitiesFlagsEXT;
+    VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264CapabilityFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
 
 typedef enum VkVideoEncodeH264InputModeFlagBitsEXT {
     VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,
@@ -475,19 +475,19 @@ typedef enum VkVideoEncodeH264CreateFlagBitsEXT {
 } VkVideoEncodeH264CreateFlagBitsEXT;
 typedef VkFlags VkVideoEncodeH264CreateFlagsEXT;
 typedef struct VkVideoEncodeH264CapabilitiesEXT {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkVideoEncodeH264CapabilitiesFlagsEXT    flags;
-    VkVideoEncodeH264InputModeFlagsEXT       inputModeFlags;
-    VkVideoEncodeH264OutputModeFlagsEXT      outputModeFlags;
-    VkExtent2D                               minPictureSizeInMbs;
-    VkExtent2D                               maxPictureSizeInMbs;
-    VkExtent2D                               inputImageDataAlignment;
-    uint8_t                                  maxNumL0ReferenceForP;
-    uint8_t                                  maxNumL0ReferenceForB;
-    uint8_t                                  maxNumL1Reference;
-    uint8_t                                  qualityLevelCount;
-    VkExtensionProperties                    stdExtensionVersion;
+    VkStructureType                        sType;
+    const void*                            pNext;
+    VkVideoEncodeH264CapabilityFlagsEXT    flags;
+    VkVideoEncodeH264InputModeFlagsEXT     inputModeFlags;
+    VkVideoEncodeH264OutputModeFlagsEXT    outputModeFlags;
+    VkExtent2D                             minPictureSizeInMbs;
+    VkExtent2D                             maxPictureSizeInMbs;
+    VkExtent2D                             inputImageDataAlignment;
+    uint8_t                                maxNumL0ReferenceForP;
+    uint8_t                                maxNumL0ReferenceForB;
+    uint8_t                                maxNumL1Reference;
+    uint8_t                                qualityLevelCount;
+    VkExtensionProperties                  stdExtensionVersion;
 } VkVideoEncodeH264CapabilitiesEXT;
 
 typedef struct VkVideoEncodeH264SessionCreateInfoEXT {
@@ -567,22 +567,22 @@ typedef struct VkVideoEncodeH264ProfileEXT {
 
 #define VK_EXT_video_decode_h264 1
 #include "vk_video/vulkan_video_codec_h264std_decode.h"
-#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 1
+#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 3
 #define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"
 
-typedef enum VkVideoDecodeH264FieldLayoutFlagBitsEXT {
-    VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT = 0,
-    VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT = 0x00000001,
-    VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT = 0x00000002,
-    VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoDecodeH264FieldLayoutFlagBitsEXT;
-typedef VkFlags VkVideoDecodeH264FieldLayoutFlagsEXT;
+typedef enum VkVideoDecodeH264PictureLayoutFlagBitsEXT {
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT = 0,
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT = 0x00000001,
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT = 0x00000002,
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoDecodeH264PictureLayoutFlagBitsEXT;
+typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsEXT;
 typedef VkFlags VkVideoDecodeH264CreateFlagsEXT;
 typedef struct VkVideoDecodeH264ProfileEXT {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    StdVideoH264ProfileIdc                  stdProfileIdc;
-    VkVideoDecodeH264FieldLayoutFlagsEXT    fieldLayout;
+    VkStructureType                           sType;
+    const void*                               pNext;
+    StdVideoH264ProfileIdc                    stdProfileIdc;
+    VkVideoDecodeH264PictureLayoutFlagsEXT    pictureLayout;
 } VkVideoDecodeH264ProfileEXT;
 
 typedef struct VkVideoDecodeH264CapabilitiesEXT {
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 60bfe58..cda3c46 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -72,7 +72,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 186
+#define VK_HEADER_VERSION 187
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp
index cce77b7..5b2cf41 100644
--- a/include/vulkan/vulkan_enums.hpp
+++ b/include/vulkan/vulkan_enums.hpp
@@ -5704,18 +5704,18 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class VideoCapabilitiesFlagBitsKHR : VkVideoCapabilitiesFlagsKHR
+  enum class VideoCapabilityFlagBitsKHR : VkVideoCapabilityFlagsKHR
   {
-    eProtectedContent        = VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR,
-    eSeparateReferenceImages = VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR
+    eProtectedContent        = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR,
+    eSeparateReferenceImages = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR
   };
 
-  VULKAN_HPP_INLINE std::string to_string( VideoCapabilitiesFlagBitsKHR value )
+  VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagBitsKHR value )
   {
     switch ( value )
     {
-      case VideoCapabilitiesFlagBitsKHR::eProtectedContent: return "ProtectedContent";
-      case VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages";
+      case VideoCapabilityFlagBitsKHR::eProtectedContent: return "ProtectedContent";
+      case VideoCapabilityFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -5843,53 +5843,36 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_EXT_video_encode_h264 ===
 
-  enum class VideoEncodeH264CapabilitiesFlagBitsEXT : VkVideoEncodeH264CapabilitiesFlagsEXT
-  {
-    eVkVideoEncodeH264CapabilityCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT,
-    eVkVideoEncodeH264CapabilityCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT,
-    eVkVideoEncodeH264CapabilityWeightedBiPredImplicit =
-      VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT,
-    eVkVideoEncodeH264CapabilityTransform8X8         = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT,
-    eVkVideoEncodeH264CapabilityChromaQpOffset       = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT,
-    eVkVideoEncodeH264CapabilitySecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT,
-    eVkVideoEncodeH264CapabilityDeblockingFilterDisabled =
-      VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
-    eVkVideoEncodeH264CapabilityDeblockingFilterEnabled =
-      VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
-    eVkVideoEncodeH264CapabilityDeblockingFilterPartial =
-      VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
-    eVkVideoEncodeH264CapabilityMultipleSlicePerFrame =
-      VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT,
-    eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize =
-      VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilitiesFlagBitsEXT value )
-  {
-    switch ( value )
-    {
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac:
-        return "VkVideoEncodeH264CapabilityCabac";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc:
-        return "VkVideoEncodeH264CapabilityCavlc";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit:
-        return "VkVideoEncodeH264CapabilityWeightedBiPredImplicit";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8:
-        return "VkVideoEncodeH264CapabilityTransform8X8";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset:
-        return "VkVideoEncodeH264CapabilityChromaQpOffset";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset:
-        return "VkVideoEncodeH264CapabilitySecondChromaQpOffset";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled:
-        return "VkVideoEncodeH264CapabilityDeblockingFilterDisabled";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled:
-        return "VkVideoEncodeH264CapabilityDeblockingFilterEnabled";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial:
-        return "VkVideoEncodeH264CapabilityDeblockingFilterPartial";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame:
-        return "VkVideoEncodeH264CapabilityMultipleSlicePerFrame";
-      case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize:
-        return "VkVideoEncodeH264CapabilityEvenlyDistributedSliceSize";
+  enum class VideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT
+  {
+    eCabac                      = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT,
+    eCavlc                      = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT,
+    eWeightedBiPredImplicit     = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT,
+    eTransform8X8               = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT,
+    eChromaQpOffset             = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT,
+    eSecondChromaQpOffset       = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT,
+    eDeblockingFilterDisabled   = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
+    eDeblockingFilterEnabled    = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
+    eDeblockingFilterPartial    = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
+    eMultipleSlicePerFrame      = VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT,
+    eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case VideoEncodeH264CapabilityFlagBitsEXT::eCabac: return "Cabac";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eCavlc: return "Cavlc";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit: return "WeightedBiPredImplicit";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8: return "Transform8X8";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset: return "ChromaQpOffset";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset: return "SecondChromaQpOffset";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled: return "DeblockingFilterDisabled";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame: return "MultipleSlicePerFrame";
+      case VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize: return "EvenlyDistributedSliceSize";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -5950,21 +5933,20 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_EXT_video_decode_h264 ===
 
-  enum class VideoDecodeH264FieldLayoutFlagBitsEXT : VkVideoDecodeH264FieldLayoutFlagsEXT
+  enum class VideoDecodeH264PictureLayoutFlagBitsEXT : VkVideoDecodeH264PictureLayoutFlagsEXT
   {
-    eVkVideoDecodeH264ProgressivePicturesOnly = VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT,
-    eLineInterlacedPlane                      = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT,
-    eSeparateInterlacedPlane                  = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT
+    eProgressive                = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT,
+    eInterlacedInterleavedLines = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT,
+    eInterlacedSeparatePlanes   = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT
   };
 
-  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagBitsEXT value )
+  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagBitsEXT value )
   {
     switch ( value )
     {
-      case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly:
-        return "VkVideoDecodeH264ProgressivePicturesOnly";
-      case VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane: return "LineInterlacedPlane";
-      case VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane: return "SeparateInterlacedPlane";
+      case VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive: return "Progressive";
+      case VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines: return "InterlacedInterleavedLines";
+      case VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes: return "InterlacedSeparatePlanes";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -11942,51 +11924,51 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  using VideoCapabilitiesFlagsKHR = Flags<VideoCapabilitiesFlagBitsKHR>;
+  using VideoCapabilityFlagsKHR = Flags<VideoCapabilityFlagBitsKHR>;
 
   template <>
-  struct FlagTraits<VideoCapabilitiesFlagBitsKHR>
+  struct FlagTraits<VideoCapabilityFlagBitsKHR>
   {
     enum : VkFlags
     {
-      allFlags = VkFlags( VideoCapabilitiesFlagBitsKHR::eProtectedContent ) |
-                 VkFlags( VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages )
+      allFlags = VkFlags( VideoCapabilityFlagBitsKHR::eProtectedContent ) |
+                 VkFlags( VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
     };
   };
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR
-                                         operator|( VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
+                                         operator|( VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
   {
-    return VideoCapabilitiesFlagsKHR( bit0 ) | bit1;
+    return VideoCapabilityFlagsKHR( bit0 ) | bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR
-                                         operator&(VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1)VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
+                                         operator&(VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1)VULKAN_HPP_NOEXCEPT
   {
-    return VideoCapabilitiesFlagsKHR( bit0 ) & bit1;
+    return VideoCapabilityFlagsKHR( bit0 ) & bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR
-                                         operator^( VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
+                                         operator^( VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
   {
-    return VideoCapabilitiesFlagsKHR( bit0 ) ^ bit1;
+    return VideoCapabilityFlagsKHR( bit0 ) ^ bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR operator~( VideoCapabilitiesFlagBitsKHR bits )
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR operator~( VideoCapabilityFlagBitsKHR bits )
     VULKAN_HPP_NOEXCEPT
   {
-    return ~( VideoCapabilitiesFlagsKHR( bits ) );
+    return ~( VideoCapabilityFlagsKHR( bits ) );
   }
 
-  VULKAN_HPP_INLINE std::string to_string( VideoCapabilitiesFlagsKHR value )
+  VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagsKHR value )
   {
     if ( !value )
       return "{}";
 
     std::string result;
-    if ( value & VideoCapabilitiesFlagBitsKHR::eProtectedContent )
+    if ( value & VideoCapabilityFlagBitsKHR::eProtectedContent )
       result += "ProtectedContent | ";
-    if ( value & VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages )
+    if ( value & VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
       result += "SeparateReferenceImages | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
@@ -12214,80 +12196,79 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_EXT_video_encode_h264 ===
 
-  using VideoEncodeH264CapabilitiesFlagsEXT = Flags<VideoEncodeH264CapabilitiesFlagBitsEXT>;
+  using VideoEncodeH264CapabilityFlagsEXT = Flags<VideoEncodeH264CapabilityFlagBitsEXT>;
 
   template <>
-  struct FlagTraits<VideoEncodeH264CapabilitiesFlagBitsEXT>
+  struct FlagTraits<VideoEncodeH264CapabilityFlagBitsEXT>
   {
     enum : VkFlags
     {
-      allFlags =
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8 ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame ) |
-        VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize )
+      allFlags = VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) |
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
     };
   };
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator|(
-    VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT operator|(
+    VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
   {
-    return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) | bit1;
+    return VideoEncodeH264CapabilityFlagsEXT( bit0 ) | bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator&(
-    VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT
+                                         operator&(VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
   {
-    return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) & bit1;
+    return VideoEncodeH264CapabilityFlagsEXT( bit0 ) & bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator^(
-    VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT operator^(
+    VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
   {
-    return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) ^ bit1;
+    return VideoEncodeH264CapabilityFlagsEXT( bit0 ) ^ bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT
-                                         operator~( VideoEncodeH264CapabilitiesFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT
+                                         operator~( VideoEncodeH264CapabilityFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
   {
-    return ~( VideoEncodeH264CapabilitiesFlagsEXT( bits ) );
+    return ~( VideoEncodeH264CapabilityFlagsEXT( bits ) );
   }
 
-  VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilitiesFlagsEXT value )
+  VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsEXT value )
   {
     if ( !value )
       return "{}";
 
     std::string result;
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac )
-      result += "VkVideoEncodeH264CapabilityCabac | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc )
-      result += "VkVideoEncodeH264CapabilityCavlc | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit )
-      result += "VkVideoEncodeH264CapabilityWeightedBiPredImplicit | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8 )
-      result += "VkVideoEncodeH264CapabilityTransform8X8 | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset )
-      result += "VkVideoEncodeH264CapabilityChromaQpOffset | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset )
-      result += "VkVideoEncodeH264CapabilitySecondChromaQpOffset | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled )
-      result += "VkVideoEncodeH264CapabilityDeblockingFilterDisabled | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled )
-      result += "VkVideoEncodeH264CapabilityDeblockingFilterEnabled | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial )
-      result += "VkVideoEncodeH264CapabilityDeblockingFilterPartial | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame )
-      result += "VkVideoEncodeH264CapabilityMultipleSlicePerFrame | ";
-    if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize )
-      result += "VkVideoEncodeH264CapabilityEvenlyDistributedSliceSize | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCabac )
+      result += "Cabac | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCavlc )
+      result += "Cavlc | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit )
+      result += "WeightedBiPredImplicit | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 )
+      result += "Transform8X8 | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset )
+      result += "ChromaQpOffset | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset )
+      result += "SecondChromaQpOffset | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled )
+      result += "DeblockingFilterDisabled | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled )
+      result += "DeblockingFilterEnabled | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial )
+      result += "DeblockingFilterPartial | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame )
+      result += "MultipleSlicePerFrame | ";
+    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
+      result += "EvenlyDistributedSliceSize | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -12446,53 +12427,53 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_EXT_video_decode_h264 ===
 
-  using VideoDecodeH264FieldLayoutFlagsEXT = Flags<VideoDecodeH264FieldLayoutFlagBitsEXT>;
+  using VideoDecodeH264PictureLayoutFlagsEXT = Flags<VideoDecodeH264PictureLayoutFlagBitsEXT>;
 
   template <>
-  struct FlagTraits<VideoDecodeH264FieldLayoutFlagBitsEXT>
+  struct FlagTraits<VideoDecodeH264PictureLayoutFlagBitsEXT>
   {
     enum : VkFlags
     {
-      allFlags = VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly ) |
-                 VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane ) |
-                 VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane )
+      allFlags = VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive ) |
+                 VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines ) |
+                 VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes )
     };
   };
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT operator|(
-    VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator|(
+    VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
   {
-    return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) | bit1;
+    return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) | bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT
-                                         operator&(VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator&(
+    VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
   {
-    return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) & bit1;
+    return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) & bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT operator^(
-    VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator^(
+    VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
   {
-    return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) ^ bit1;
+    return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) ^ bit1;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT
-                                         operator~( VideoDecodeH264FieldLayoutFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT
+                                         operator~( VideoDecodeH264PictureLayoutFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
   {
-    return ~( VideoDecodeH264FieldLayoutFlagsEXT( bits ) );
+    return ~( VideoDecodeH264PictureLayoutFlagsEXT( bits ) );
   }
 
-  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagsEXT value )
+  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsEXT value )
   {
     if ( !value )
       return "{}";
 
     std::string result;
-    if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane )
-      result += "LineInterlacedPlane | ";
-    if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane )
-      result += "SeparateInterlacedPlane | ";
+    if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines )
+      result += "InterlacedInterleavedLines | ";
+    if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes )
+      result += "InterlacedSeparatePlanes | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp
index 5118aa7..b2b8da8 100644
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
@@ -67259,7 +67259,7 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCapabilitiesKHR;
 
 #  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR VideoCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoCapabilitiesFlagsKHR capabilityFlags_    = {},
+    VULKAN_HPP_CONSTEXPR VideoCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR capabilityFlags_      = {},
                                                VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment_ = {},
                                                VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment_   = {},
                                                VULKAN_HPP_NAMESPACE::Extent2D   videoPictureExtentGranularity_     = {},
@@ -67324,16 +67324,16 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType             sType           = StructureType::eVideoCapabilitiesKHR;
-    void *                                          pNext           = {};
-    VULKAN_HPP_NAMESPACE::VideoCapabilitiesFlagsKHR capabilityFlags = {};
-    VULKAN_HPP_NAMESPACE::DeviceSize                minBitstreamBufferOffsetAlignment = {};
-    VULKAN_HPP_NAMESPACE::DeviceSize                minBitstreamBufferSizeAlignment   = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                  videoPictureExtentGranularity     = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                  minExtent                         = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                  maxExtent                         = {};
-    uint32_t                                        maxReferencePicturesSlotsCount    = {};
-    uint32_t                                        maxReferencePicturesActiveCount   = {};
+    VULKAN_HPP_NAMESPACE::StructureType           sType           = StructureType::eVideoCapabilitiesKHR;
+    void *                                        pNext           = {};
+    VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR capabilityFlags = {};
+    VULKAN_HPP_NAMESPACE::DeviceSize              minBitstreamBufferOffsetAlignment = {};
+    VULKAN_HPP_NAMESPACE::DeviceSize              minBitstreamBufferSizeAlignment   = {};
+    VULKAN_HPP_NAMESPACE::Extent2D                videoPictureExtentGranularity     = {};
+    VULKAN_HPP_NAMESPACE::Extent2D                minExtent                         = {};
+    VULKAN_HPP_NAMESPACE::Extent2D                maxExtent                         = {};
+    uint32_t                                      maxReferencePicturesSlotsCount    = {};
+    uint32_t                                      maxReferencePicturesActiveCount   = {};
   };
   static_assert( sizeof( VideoCapabilitiesKHR ) == sizeof( VkVideoCapabilitiesKHR ),
                  "struct and wrapper have different size!" );
@@ -67805,10 +67805,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
     VULKAN_HPP_CONSTEXPR VideoDecodeH264ProfileEXT(
-      StdVideoH264ProfileIdc                                   stdProfileIdc_ = {},
-      VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout_   = {} ) VULKAN_HPP_NOEXCEPT
+      StdVideoH264ProfileIdc                                     stdProfileIdc_ = {},
+      VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout_ = {} ) VULKAN_HPP_NOEXCEPT
       : stdProfileIdc( stdProfileIdc_ )
-      , fieldLayout( fieldLayout_ )
+      , pictureLayout( pictureLayout_ )
     {}
 
     VULKAN_HPP_CONSTEXPR
@@ -67842,9 +67842,9 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     VideoDecodeH264ProfileEXT &
-      setFieldLayout( VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout_ ) VULKAN_HPP_NOEXCEPT
+      setPictureLayout( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout_ ) VULKAN_HPP_NOEXCEPT
     {
-      fieldLayout = fieldLayout_;
+      pictureLayout = pictureLayout_;
       return *this;
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
@@ -67866,7 +67866,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
              ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) &&
-             ( fieldLayout == rhs.fieldLayout );
+             ( pictureLayout == rhs.pictureLayout );
     }
 
     bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
@@ -67876,10 +67876,10 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType                      sType         = StructureType::eVideoDecodeH264ProfileEXT;
-    const void *                                             pNext         = {};
-    StdVideoH264ProfileIdc                                   stdProfileIdc = {};
-    VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout   = {};
+    VULKAN_HPP_NAMESPACE::StructureType                        sType = StructureType::eVideoDecodeH264ProfileEXT;
+    const void *                                               pNext = {};
+    StdVideoH264ProfileIdc                                     stdProfileIdc = {};
+    VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout = {};
   };
   static_assert( sizeof( VideoDecodeH264ProfileEXT ) == sizeof( VkVideoDecodeH264ProfileEXT ),
                  "struct and wrapper have different size!" );
@@ -69193,17 +69193,17 @@ namespace VULKAN_HPP_NAMESPACE
 
 #  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
     VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags_                   = {},
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT    inputModeFlags_          = {},
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT   outputModeFlags_         = {},
-      VULKAN_HPP_NAMESPACE::Extent2D                            minPictureSizeInMbs_     = {},
-      VULKAN_HPP_NAMESPACE::Extent2D                            maxPictureSizeInMbs_     = {},
-      VULKAN_HPP_NAMESPACE::Extent2D                            inputImageDataAlignment_ = {},
-      uint8_t                                                   maxNumL0ReferenceForP_   = {},
-      uint8_t                                                   maxNumL0ReferenceForB_   = {},
-      uint8_t                                                   maxNumL1Reference_       = {},
-      uint8_t                                                   qualityLevelCount_       = {},
-      VULKAN_HPP_NAMESPACE::ExtensionProperties                 stdExtensionVersion_     = {} ) VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_                   = {},
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT  inputModeFlags_          = {},
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_         = {},
+      VULKAN_HPP_NAMESPACE::Extent2D                          minPictureSizeInMbs_     = {},
+      VULKAN_HPP_NAMESPACE::Extent2D                          maxPictureSizeInMbs_     = {},
+      VULKAN_HPP_NAMESPACE::Extent2D                          inputImageDataAlignment_ = {},
+      uint8_t                                                 maxNumL0ReferenceForP_   = {},
+      uint8_t                                                 maxNumL0ReferenceForB_   = {},
+      uint8_t                                                 maxNumL1Reference_       = {},
+      uint8_t                                                 qualityLevelCount_       = {},
+      VULKAN_HPP_NAMESPACE::ExtensionProperties               stdExtensionVersion_     = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
       , inputModeFlags( inputModeFlags_ )
       , outputModeFlags( outputModeFlags_ )
@@ -69242,7 +69242,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     VideoEncodeH264CapabilitiesEXT &
-      setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
+      setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
     {
       flags = flags_;
       return *this;
@@ -69346,19 +69346,19 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType                       sType = StructureType::eVideoEncodeH264CapabilitiesEXT;
-    const void *                                              pNext = {};
-    VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags = {};
-    VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT    inputModeFlags          = {};
-    VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT   outputModeFlags         = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                            minPictureSizeInMbs     = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                            maxPictureSizeInMbs     = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                            inputImageDataAlignment = {};
-    uint8_t                                                   maxNumL0ReferenceForP   = {};
-    uint8_t                                                   maxNumL0ReferenceForB   = {};
-    uint8_t                                                   maxNumL1Reference       = {};
-    uint8_t                                                   qualityLevelCount       = {};
-    VULKAN_HPP_NAMESPACE::ExtensionProperties                 stdExtensionVersion     = {};
+    VULKAN_HPP_NAMESPACE::StructureType                     sType = StructureType::eVideoEncodeH264CapabilitiesEXT;
+    const void *                                            pNext = {};
+    VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {};
+    VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT  inputModeFlags          = {};
+    VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags         = {};
+    VULKAN_HPP_NAMESPACE::Extent2D                          minPictureSizeInMbs     = {};
+    VULKAN_HPP_NAMESPACE::Extent2D                          maxPictureSizeInMbs     = {};
+    VULKAN_HPP_NAMESPACE::Extent2D                          inputImageDataAlignment = {};
+    uint8_t                                                 maxNumL0ReferenceForP   = {};
+    uint8_t                                                 maxNumL0ReferenceForB   = {};
+    uint8_t                                                 maxNumL1Reference       = {};
+    uint8_t                                                 qualityLevelCount       = {};
+    VULKAN_HPP_NAMESPACE::ExtensionProperties               stdExtensionVersion     = {};
   };
   static_assert( sizeof( VideoEncodeH264CapabilitiesEXT ) == sizeof( VkVideoEncodeH264CapabilitiesEXT ),
                  "struct and wrapper have different size!" );
diff --git a/registry/validusage.json b/registry/validusage.json
index 258dc9c..8deb304 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.186",
-    "comment": "from git branch: github-main commit: 907c556530050b0f4af073753335f23c885c02bf",
-    "date": "2021-07-27 09:51:57Z"
+    "api version": "1.2.187",
+    "comment": "from git branch: github-main commit: cd8da6a515811c4ff9e1f10a6d6ce4ab968333fb",
+    "date": "2021-08-03 11:15:40Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -828,7 +828,7 @@
         },
         {
           "vuid": "VUID-vkGetDeviceQueue-queueIndex-00385",
-          "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index when <code>device</code> was created, via the <code>queueCount</code> member of the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
+          "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the value of <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a>::<code>queueCount</code> for the queue family indicated by <code>queueFamilyIndex</code> when <code>device</code> was created"
         },
         {
           "vuid": "VUID-vkGetDeviceQueue-flags-01841",
@@ -867,8 +867,12 @@
           "text": " <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be one of the queue family indices specified when <code>device</code> was created, via the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
         },
         {
+          "vuid": "VUID-VkDeviceQueueInfo2-flags-06225",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be equal to <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a>::<code>flags</code> for a <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure for the queue family indicated by <code>queueFamilyIndex</code> when <code>device</code> was created"
+        },
+        {
           "vuid": "VUID-VkDeviceQueueInfo2-queueIndex-01843",
-          "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index and <a href=\"#VkDeviceQueueCreateFlags\">VkDeviceQueueCreateFlags</a> member <code>flags</code> equal to this <code>flags</code> value when <code>device</code> was created, via the <code>queueCount</code> member of the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
+          "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a>::<code>queueCount</code> for the corresponding queue family and flags indicated by <code>queueFamilyIndex</code> and <code>flags</code> when <code>device</code> was created"
         },
         {
           "vuid": "VUID-VkDeviceQueueInfo2-sType-sType",
@@ -3425,7 +3429,7 @@
           "text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:stageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
         },
         {
-          "vuid": "VUID-vkCmdSetEvent-stageMask-4098",
+          "vuid": "VUID-vkCmdSetEvent-stageMask-04098",
           "text": " Any pipeline stage included in pname:stageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
         },
         {
@@ -3637,7 +3641,7 @@
           "text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:stageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
         },
         {
-          "vuid": "VUID-vkCmdResetEvent-stageMask-4098",
+          "vuid": "VUID-vkCmdResetEvent-stageMask-04098",
           "text": " Any pipeline stage included in pname:stageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
         },
         {
@@ -3821,7 +3825,7 @@
           "text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:srcStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
         },
         {
-          "vuid": "VUID-vkCmdWaitEvents-srcStageMask-4098",
+          "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04098",
           "text": " Any pipeline stage included in pname:srcStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
         },
         {
@@ -3833,7 +3837,7 @@
           "text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:dstStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
         },
         {
-          "vuid": "VUID-vkCmdWaitEvents-dstStageMask-4098",
+          "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04098",
           "text": " Any pipeline stage included in pname:dstStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
         },
         {
@@ -4075,7 +4079,7 @@
           "text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:srcStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-4098",
+          "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04098",
           "text": " Any pipeline stage included in pname:srcStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
         },
         {
@@ -4087,7 +4091,7 @@
           "text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:dstStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-4098",
+          "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04098",
           "text": " Any pipeline stage included in pname:dstStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
         },
         {
@@ -7998,11 +8002,11 @@
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-renderArea-02848",
-          "text": " <span class=\"eq\"><code>renderArea.offset.x</code> &#43; <code>renderArea.offset.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
+          "text": " <span class=\"eq\"><code>renderArea.offset.x</code> &#43; <code>renderArea.extent.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-renderArea-02849",
-          "text": " <span class=\"eq\"><code>renderArea.offset.y</code> &#43; <code>renderArea.offset.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
+          "text": " <span class=\"eq\"><code>renderArea.offset.y</code> &#43; <code>renderArea.extent.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
         }
       ],
       "(VK_VERSION_1_1,VK_KHR_device_group)": [
@@ -8016,11 +8020,11 @@
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-pNext-02852",
-          "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.x</code> &#43; <code>renderArea.offset.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
+          "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.x</code> &#43; <code>renderArea.extent.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-pNext-02853",
-          "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.y</code> &#43; <code>renderArea.offset.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
+          "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.y</code> &#43; <code>renderArea.extent.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-pNext-02854",
@@ -8032,11 +8036,11 @@
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-pNext-02856",
-          "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.x</code> &#43; <code>offset.width</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
+          "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.x</code> &#43; <code>extent.width</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-pNext-02857",
-          "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.y</code> &#43; <code>offset.height</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
+          "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.y</code> &#43; <code>extent.height</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
         }
       ],
       "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [
@@ -10071,7 +10075,7 @@
           "text": " The number of resources in <code>layout</code> accessible to each shader stage that is used by the pipeline <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>maxPerStageResources</code>"
         },
         {
-          "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-stage-03425",
+          "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-stage-06232",
           "text": " The <code>stage</code> member of at least one element of <code>pStages</code> <strong class=\"purple\">must</strong> be <code>VK_SHADER_STAGE_RAYGEN_BIT_KHR</code>"
         },
         {
@@ -11549,6 +11553,12 @@
           "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA</code>, the value of <code>allocationSize</code> <strong class=\"purple\">must</strong> be greater than <code>0</code> and <strong class=\"purple\">must</strong> be less than or equal to the size of the VMO as determined by <code>zx_vmo_get_size</code>(<code>handle</code>) where <code>handle</code> is the VMO handle to the imported external memory."
         }
       ],
+      "(VK_KHR_maintenance3)": [
+        {
+          "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-06231",
+          "text": " <code>allocationSize</code> <strong class=\"purple\">must</strong> be less than <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>::<code>maxMemoryAllocationSize</code>."
+        }
+      ],
       "core": [
         {
           "vuid": "VUID-VkMemoryAllocateInfo-sType-sType",
@@ -22685,7 +22695,7 @@
       ],
       "core": [
         {
-          "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00172",
+          "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06217",
           "text": " The image region specified by each element of <code>pRegions</code> <strong class=\"purple\">must</strong> be contained within the specified <code>imageSubresource</code> of <code>dstImage</code>"
         },
         {
@@ -22737,11 +22747,11 @@
           "text": " If the queue family used to create the <a href=\"#VkCommandPool\">VkCommandPool</a> which <code>commandBuffer</code> was allocated from does not support <code>VK_QUEUE_GRAPHICS_BIT</code>, for each element of <code>pRegions</code>, the <code>aspectMask</code> member of <code>imageSubresource</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_ASPECT_DEPTH_BIT</code> or <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>."
         },
         {
-          "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00197",
+          "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06218",
           "text": " For each element of <code>pRegions</code>, <code>imageOffset.x</code> and <span class=\"eq\">(<code>imageExtent.width</code> &#43; <code>imageOffset.x</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>imageSubresource</code> of <code>dstImage</code>"
         },
         {
-          "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00198",
+          "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06219",
           "text": " For each element of <code>pRegions</code>, <code>imageOffset.y</code> and <span class=\"eq\">(<code>imageExtent.height</code> &#43; <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>dstImage</code>"
         },
         {
@@ -22917,7 +22927,7 @@
       ],
       "core": [
         {
-          "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00182",
+          "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06220",
           "text": " The image region specified by each element of <code>pRegions</code> <strong class=\"purple\">must</strong> be contained within the specified <code>imageSubresource</code> of <code>srcImage</code>"
         },
         {
@@ -22965,11 +22975,11 @@
           "text": " The <code>imageOffset</code> and <code>imageExtent</code> members of each element of <code>pRegions</code> <strong class=\"purple\">must</strong> respect the image transfer granularity requirements of <code>commandBuffer</code>&#8217;s command pool&#8217;s queue family, as described in <a href=\"#VkQueueFamilyProperties\">VkQueueFamilyProperties</a>"
         },
         {
-          "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-00197",
+          "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06221",
           "text": " For each element of <code>pRegions</code>, <code>imageOffset.x</code> and <span class=\"eq\">(<code>imageExtent.width</code> &#43; <code>imageOffset.x</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>imageSubresource</code> of <code>srcImage</code>"
         },
         {
-          "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-00198",
+          "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06222",
           "text": " For each element of <code>pRegions</code>, <code>imageOffset.y</code> and <span class=\"eq\">(imageExtent.height &#43; <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>srcImage</code>"
         },
         {
@@ -23259,11 +23269,11 @@
           "text": " If the queue family used to create the <a href=\"#VkCommandPool\">VkCommandPool</a> which <code>commandBuffer</code> was allocated from does not support <code>VK_QUEUE_GRAPHICS_BIT</code>, for each element of <code>pRegions</code>, the <code>aspectMask</code> member of <code>imageSubresource</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_ASPECT_DEPTH_BIT</code> or <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>."
         },
         {
-          "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-00197",
+          "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06223",
           "text": " For each element of <code>pRegions</code> not containing <a href=\"#VkCopyCommandTransformInfoQCOM\">VkCopyCommandTransformInfoQCOM</a> in its <code>pNext</code> chain, <code>imageOffset.x</code> and <span class=\"eq\">(<code>imageExtent.width</code> &#43; <code>imageOffset.x</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>imageSubresource</code> of <code>dstImage</code>"
         },
         {
-          "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-00198",
+          "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06224",
           "text": " For each element of <code>pRegions</code> not containing <a href=\"#VkCopyCommandTransformInfoQCOM\">VkCopyCommandTransformInfoQCOM</a> in its <code>pNext</code> chain, <code>imageOffset.y</code> and <span class=\"eq\">(<code>imageExtent.height</code> &#43; <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>dstImage</code>"
         },
         {
@@ -29325,11 +29335,11 @@
           "text": " If the <a href=\"#features-vertexAttributeInstanceRateDivisor\">vertexAttributeInstanceRateDivisor</a> feature is not enabled, <code>divisor</code> <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
-          "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-04800",
+          "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-06226",
           "text": " <code>divisor</code> <strong class=\"purple\">must</strong> be a value between <code>0</code> and <code>VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</code>::<code>maxVertexAttribDivisor</code>, inclusive"
         },
         {
-          "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-04801",
+          "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-06227",
           "text": " If <code>divisor</code> is not <code>1</code> then <code>inputRate</code> <strong class=\"purple\">must</strong> be of type <code>VK_VERTEX_INPUT_RATE_INSTANCE</code>"
         },
         {
@@ -29345,15 +29355,15 @@
     "VkVertexInputAttributeDescription2EXT": {
       "(VK_EXT_vertex_input_dynamic_state)": [
         {
-          "vuid": "VUID-VkVertexInputAttributeDescription2EXT-location-04802",
+          "vuid": "VUID-VkVertexInputAttributeDescription2EXT-location-06228",
           "text": " <code>location</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputAttributes</code>"
         },
         {
-          "vuid": "VUID-VkVertexInputAttributeDescription2EXT-binding-04803",
+          "vuid": "VUID-VkVertexInputAttributeDescription2EXT-binding-06229",
           "text": " <code>binding</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputBindings</code>"
         },
         {
-          "vuid": "VUID-VkVertexInputAttributeDescription2EXT-offset-04804",
+          "vuid": "VUID-VkVertexInputAttributeDescription2EXT-offset-06230",
           "text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputAttributeOffset</code>"
         },
         {
@@ -37721,11 +37731,11 @@
           "text": " All acceleration structures in <code>pAccelerationStructures</code> <strong class=\"purple\">must</strong> have been built prior to the execution of this command"
         },
         {
-          "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructures-03431",
+          "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-pAccelerationStructures-06215",
           "text": " All acceleration structures in <code>pAccelerationStructures</code> <strong class=\"purple\">must</strong> have been built with <code>VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR</code> if <code>queryType</code> is <code>VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV</code>"
         },
         {
-          "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-03432",
+          "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-06216",
           "text": " <code>queryType</code> <strong class=\"purple\">must</strong> be <code>VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV</code>"
         },
         {
@@ -38634,7 +38644,7 @@
         },
         {
           "vuid": "VUID-vkCmdTraceRaysNV-maxRecursionDepth-03625",
-          "text": " This command <strong class=\"purple\">must</strong> not cause a trace ray instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
+          "text": " This command <strong class=\"purple\">must</strong> not cause a pipeline trace ray instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
         },
         {
           "vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-04042",
@@ -40243,12 +40253,12 @@
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT</code>"
         },
         {
-          "vuid": "VUID-VkVideoDecodeH264ProfileEXT-fieldLayout-parameter",
-          "text": " <code>fieldLayout</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoDecodeH264FieldLayoutFlagBitsEXT\">VkVideoDecodeH264FieldLayoutFlagBitsEXT</a> values"
+          "vuid": "VUID-VkVideoDecodeH264ProfileEXT-pictureLayout-parameter",
+          "text": " <code>pictureLayout</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoDecodeH264PictureLayoutFlagBitsEXT\">VkVideoDecodeH264PictureLayoutFlagBitsEXT</a> values"
         },
         {
-          "vuid": "VUID-VkVideoDecodeH264ProfileEXT-fieldLayout-requiredbitmask",
-          "text": " <code>fieldLayout</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
+          "vuid": "VUID-VkVideoDecodeH264ProfileEXT-pictureLayout-requiredbitmask",
+          "text": " <code>pictureLayout</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
         }
       ]
     },
@@ -40620,7 +40630,7 @@
         },
         {
           "vuid": "VUID-VkVideoEncodeH264CapabilitiesEXT-flags-parameter",
-          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoEncodeH264CapabilitiesFlagBitsEXT\">VkVideoEncodeH264CapabilitiesFlagBitsEXT</a> values"
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoEncodeH264CapabilityFlagBitsEXT\">VkVideoEncodeH264CapabilityFlagBitsEXT</a> values"
         },
         {
           "vuid": "VUID-VkVideoEncodeH264CapabilitiesEXT-flags-requiredbitmask",
diff --git a/registry/vk.xml b/registry/vk.xml
index 81901e6..55b5610 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -155,7 +155,7 @@ branch of the member gitlab server.
         <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 186</type>
+#define <name>VK_HEADER_VERSION</name> 187</type>
         <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, VK_HEADER_VERSION)</type>
 
@@ -386,7 +386,7 @@ typedef void <name>CAMetalLayer</name>;
 
             <comment>Video Core extension</comment>
         <type requires="VkVideoCodecOperationFlagBitsKHR"           category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCodecOperationFlagsKHR</name>;</type>
-        <type requires="VkVideoCapabilitiesFlagBitsKHR"             category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCapabilitiesFlagsKHR</name>;</type>
+        <type requires="VkVideoCapabilityFlagBitsKHR"               category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCapabilityFlagsKHR</name>;</type>
         <type requires="VkVideoSessionCreateFlagBitsKHR"            category="bitmask">typedef <type>VkFlags</type> <name>VkVideoSessionCreateFlagsKHR</name>;</type>
         <type                                                       category="bitmask">typedef <type>VkFlags</type> <name>VkVideoBeginCodingFlagsKHR</name>;</type>
         <type                                                       category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEndCodingFlagsKHR</name>;</type>
@@ -397,7 +397,7 @@ typedef void <name>CAMetalLayer</name>;
         <type requires="VkVideoDecodeFlagBitsKHR"                   category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeFlagsKHR</name>;</type>
 
             <comment>Video Decode H.264 extension</comment>
-        <type requires="VkVideoDecodeH264FieldLayoutFlagBitsEXT"    category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264FieldLayoutFlagsEXT</name>;</type>
+        <type requires="VkVideoDecodeH264PictureLayoutFlagBitsEXT"  category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264PictureLayoutFlagsEXT</name>;</type>
         <type                                                       category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264CreateFlagsEXT</name>;</type>
 
             <comment>Video Decode H.265 extension</comment>
@@ -411,7 +411,7 @@ typedef void <name>CAMetalLayer</name>;
         <type requires="VkVideoComponentBitDepthFlagBitsKHR"        category="bitmask">typedef <type>VkFlags</type> <name>VkVideoComponentBitDepthFlagsKHR</name>;</type>
 
             <comment>Video Encode H.264 extension</comment>
-        <type requires="VkVideoEncodeH264CapabilitiesFlagBitsEXT"   category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CapabilitiesFlagsEXT</name>;</type>
+        <type requires="VkVideoEncodeH264CapabilityFlagBitsEXT"     category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CapabilityFlagsEXT</name>;</type>
         <type requires="VkVideoEncodeH264InputModeFlagBitsEXT"      category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264InputModeFlagsEXT</name>;</type>
         <type requires="VkVideoEncodeH264OutputModeFlagBitsEXT"     category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264OutputModeFlagsEXT</name>;</type>
         <type requires="VkVideoEncodeH264CreateFlagBitsEXT"         category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CreateFlagsEXT</name>;</type>
@@ -698,7 +698,7 @@ typedef void <name>CAMetalLayer</name>;
         <type name="VkVideoCodecOperationFlagBitsKHR" category="enum"/>
         <type name="VkVideoChromaSubsamplingFlagBitsKHR" category="enum"/>
         <type name="VkVideoComponentBitDepthFlagBitsKHR" category="enum"/>
-        <type name="VkVideoCapabilitiesFlagBitsKHR" category="enum"/>
+        <type name="VkVideoCapabilityFlagBitsKHR" category="enum"/>
         <type name="VkVideoSessionCreateFlagBitsKHR" category="enum"/>
         <type name="VkVideoCodingQualityPresetFlagBitsKHR" category="enum"/>
         <type name="VkVideoCodingControlFlagBitsKHR" category="enum"/>
@@ -708,7 +708,7 @@ typedef void <name>CAMetalLayer</name>;
         <type name="VkVideoDecodeFlagBitsKHR" category="enum"/>
 
             <comment>Video H.264 Decode extensions</comment>
-        <type name="VkVideoDecodeH264FieldLayoutFlagBitsEXT" category="enum"/>
+        <type name="VkVideoDecodeH264PictureLayoutFlagBitsEXT" category="enum"/>
 
             <comment>Video H.265 Decode extensions</comment>
 
@@ -718,7 +718,7 @@ typedef void <name>CAMetalLayer</name>;
         <type name="VkVideoEncodeRateControlModeFlagBitsKHR" category="enum"/>
 
            <comment>Video H.264 Encode extensions</comment>
-        <type name="VkVideoEncodeH264CapabilitiesFlagBitsEXT"   category="enum"/>
+        <type name="VkVideoEncodeH264CapabilityFlagBitsEXT"     category="enum"/>
         <type name="VkVideoEncodeH264InputModeFlagBitsEXT"      category="enum"/>
         <type name="VkVideoEncodeH264OutputModeFlagBitsEXT"     category="enum"/>
         <type name="VkVideoEncodeH264CreateFlagBitsEXT"         category="enum"/>
@@ -5564,7 +5564,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkVideoCapabilitiesKHR" returnedonly="true">
           <member values="VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"><type>VkStructureType</type><name>sType</name></member>
           <member><type>void</type>*                            <name>pNext</name></member>
-          <member><type>VkVideoCapabilitiesFlagsKHR</type>      <name>capabilityFlags</name></member>
+          <member><type>VkVideoCapabilityFlagsKHR</type>        <name>capabilityFlags</name></member>
           <member><type>VkDeviceSize</type>                     <name>minBitstreamBufferOffsetAlignment</name></member>
           <member><type>VkDeviceSize</type>                     <name>minBitstreamBufferSizeAlignment</name></member>
           <member><type>VkExtent2D</type>                       <name>videoPictureExtentGranularity</name></member>
@@ -5645,9 +5645,9 @@ typedef void <name>CAMetalLayer</name>;
         <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264MvcElementFlags"/>
         <type category="struct" name="VkVideoDecodeH264ProfileEXT" structextends="VkVideoProfileKHR">
           <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"><type>VkStructureType</type><name>sType</name></member>
-          <member>const <type>void</type>*                          <name>pNext</name></member>
-          <member><type>StdVideoH264ProfileIdc</type>               <name>stdProfileIdc</name></member>
-          <member><type>VkVideoDecodeH264FieldLayoutFlagsEXT</type> <name>fieldLayout</name></member>
+          <member>const <type>void</type>*                            <name>pNext</name></member>
+          <member><type>StdVideoH264ProfileIdc</type>                 <name>stdProfileIdc</name></member>
+          <member><type>VkVideoDecodeH264PictureLayoutFlagsEXT</type> <name>pictureLayout</name></member>
         </type>
         <type category="struct" name="VkVideoDecodeH264CapabilitiesEXT" returnedonly="true" structextends="VkVideoCapabilitiesKHR">
           <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
@@ -5833,7 +5833,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkVideoEncodeH264CapabilitiesEXT" structextends="VkVideoCapabilitiesKHR">
           <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
           <member>const <type>void</type>*                           <name>pNext</name></member>
-          <member><type>VkVideoEncodeH264CapabilitiesFlagsEXT</type> <name>flags</name></member>
+          <member><type>VkVideoEncodeH264CapabilityFlagsEXT</type>   <name>flags</name></member>
           <member><type>VkVideoEncodeH264InputModeFlagsEXT</type>    <name>inputModeFlags</name></member>
           <member><type>VkVideoEncodeH264OutputModeFlagsEXT</type>   <name>outputModeFlags</name></member>
           <member><type>VkExtent2D</type>                            <name>minPictureSizeInMbs</name></member>
@@ -7564,9 +7564,9 @@ typedef void <name>CAMetalLayer</name>;
         <enum bitpos="2"    name="VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR"/>
         <enum bitpos="4"    name="VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR"/>
     </enums>
-    <enums name="VkVideoCapabilitiesFlagBitsKHR" type="bitmask">
-        <enum bitpos="0"    name="VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR"/>
-        <enum bitpos="1"    name="VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR"/>
+    <enums name="VkVideoCapabilityFlagBitsKHR" type="bitmask">
+        <enum bitpos="0"    name="VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR"/>
+        <enum bitpos="1"    name="VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR"/>
     </enums>
     <enums name="VkVideoSessionCreateFlagBitsKHR" type="bitmask">
         <enum value="0"     name="VK_VIDEO_SESSION_CREATE_DEFAULT_KHR"/>
@@ -7578,10 +7578,10 @@ typedef void <name>CAMetalLayer</name>;
         <enum bitpos="1"       name="VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR"/>
         <enum bitpos="2"       name="VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR"/>
     </enums>
-    <enums name="VkVideoDecodeH264FieldLayoutFlagBitsEXT" type="bitmask">
-        <enum value="0"       name="VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT"/>
-        <enum bitpos="0"      name="VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT"/>
-        <enum bitpos="1"      name="VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT"/>
+    <enums name="VkVideoDecodeH264PictureLayoutFlagBitsEXT" type="bitmask">
+        <enum value="0"       name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT"/>
+        <enum bitpos="0"      name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT"/>
+        <enum bitpos="1"      name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT"/>
     </enums>
     <enums name="VkVideoCodingControlFlagBitsKHR" type="bitmask">
         <enum value="0"     name="VK_VIDEO_CODING_CONTROL_DEFAULT_KHR"/>
@@ -7609,7 +7609,7 @@ typedef void <name>CAMetalLayer</name>;
         <enum value="1"      name="VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR"/>
         <enum value="2"      name="VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR"/>
     </enums>
-    <enums name="VkVideoEncodeH264CapabilitiesFlagBitsEXT" type="bitmask">
+    <enums name="VkVideoEncodeH264CapabilityFlagBitsEXT" type="bitmask">
         <enum bitpos="0"      name="VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT"/>
         <enum bitpos="1"      name="VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT"/>
         <enum bitpos="2"      name="VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT"/>
@@ -10683,13 +10683,13 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>uint32_t</type> <name>connectorId</name></param>
             <param><type>VkDisplayKHR</type>* <name>display</name></param>
         </command>
-	<command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
-	    <proto><type>VkResult</type> <name>vkWaitForPresentKHR</name></proto>
-	    <param><type>VkDevice</type> <name>device</name></param>
-	    <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
-	    <param><type>uint64_t</type> <name>presentId</name></param>
-	    <param><type>uint64_t</type> <name>timeout</name></param>
-	</command>
+        <command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
+            <proto><type>VkResult</type> <name>vkWaitForPresentKHR</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
+            <param><type>uint64_t</type> <name>presentId</name></param>
+            <param><type>uint64_t</type> <name>timeout</name></param>
+        </command>
     </commands>
 
     <feature api="vulkan" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@@ -12033,7 +12033,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_video_queue" number="24" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_sampler_ycbcr_conversion" author="KHR" contact="Tony Zlatinski @tzlatinski" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="1"                                         name="VK_KHR_VIDEO_QUEUE_SPEC_VERSION"/>
+                <enum value="2"                                         name="VK_KHR_VIDEO_QUEUE_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_video_queue&quot;"            name="VK_KHR_VIDEO_QUEUE_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -12067,8 +12067,8 @@ typedef void <name>CAMetalLayer</name>;
                 <type name="VkVideoChromaSubsamplingFlagsKHR"/>
                 <type name="VkVideoComponentBitDepthFlagBitsKHR"/>
                 <type name="VkVideoComponentBitDepthFlagsKHR"/>
-                <type name="VkVideoCapabilitiesFlagBitsKHR"/>
-                <type name="VkVideoCapabilitiesFlagsKHR"/>
+                <type name="VkVideoCapabilityFlagBitsKHR"/>
+                <type name="VkVideoCapabilityFlagsKHR"/>
                 <type name="VkVideoSessionCreateFlagBitsKHR"/>
                 <type name="VkVideoSessionCreateFlagsKHR"/>
                 <type name="VkVideoBeginCodingFlagsKHR"/>
@@ -12277,7 +12277,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_video_encode_h264" number="39" type="device" requires="VK_KHR_video_encode_queue" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="1"                                                 name="VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION"/>
+                <enum value="2"                                                 name="VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_video_encode_h264&quot;"              name="VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -12290,8 +12290,8 @@ typedef void <name>CAMetalLayer</name>;
                 <enum offset="8" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum bitpos="16" extends="VkVideoCodecOperationFlagBitsKHR"    name="VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
 
-                <type name="VkVideoEncodeH264CapabilitiesFlagBitsEXT"/>
-                <type name="VkVideoEncodeH264CapabilitiesFlagsEXT"/>
+                <type name="VkVideoEncodeH264CapabilityFlagBitsEXT"/>
+                <type name="VkVideoEncodeH264CapabilityFlagsEXT"/>
                 <type name="VkVideoEncodeH264InputModeFlagBitsEXT"/>
                 <type name="VkVideoEncodeH264InputModeFlagsEXT"/>
                 <type name="VkVideoEncodeH264OutputModeFlagBitsEXT"/>
@@ -12317,7 +12317,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_video_decode_h264" number="41" type="device" requires="VK_KHR_video_decode_queue" author="KHR" contact="[email protected]" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="1"                                              name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
+                <enum value="3"                                              name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_video_decode_h264&quot;"           name="VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -12328,8 +12328,8 @@ typedef void <name>CAMetalLayer</name>;
                 <enum offset="6" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="7" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum bitpos="0" extends="VkVideoCodecOperationFlagBitsKHR"  name="VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-                <type name="VkVideoDecodeH264FieldLayoutFlagBitsEXT"/>
-                <type name="VkVideoDecodeH264FieldLayoutFlagsEXT"/>
+                <type name="VkVideoDecodeH264PictureLayoutFlagBitsEXT"/>
+                <type name="VkVideoDecodeH264PictureLayoutFlagsEXT"/>
                 <type name="VkVideoDecodeH264CreateFlagsEXT"/>
                 <type name="VkVideoDecodeH264ProfileEXT"/>
                 <type name="VkVideoDecodeH264CapabilitiesEXT"/>
@@ -15035,9 +15035,9 @@ typedef void <name>CAMetalLayer</name>;
             <require>
                 <enum value="1"                                         name="VK_KHR_PRESENT_WAIT_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_present_wait&quot;"           name="VK_KHR_PRESENT_WAIT_EXTENSION_NAME"/>
-		<command name="vkWaitForPresentKHR"/>
-		<enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"/>
-		<type name="VkPhysicalDevicePresentWaitFeaturesKHR"/>
+                <command name="vkWaitForPresentKHR"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"/>
+                <type name="VkPhysicalDevicePresentWaitFeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_NV_cooperative_matrix" number="250" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
@@ -15577,8 +15577,8 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_KHR_present_id&quot;"             name="VK_KHR_PRESENT_ID_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PRESENT_ID_KHR"/>
                 <type name="VkPresentIdKHR"/>
-		<enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"/>
-		<type name="VkPhysicalDevicePresentIdFeaturesKHR"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"/>
+                <type name="VkPhysicalDevicePresentIdFeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_EXT_private_data" number="296" type="device" author="NV" contact="Matthew Rusch @mattruschnv" supported="vulkan">
@@ -16678,6 +16678,12 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_KHR_extension_421&quot;"              name="VK_KHR_EXTENSION_421_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_EXT_extension_422" number="422" author="EXT" contact="Graeme Leese @gnl21" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_422_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_422&quot;"              name="VK_EXT_EXTENSION_422_EXTENSION_NAME"/>
+            </require>
+        </extension>
 
     </extensions>
     <spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it">