Update for Vulkan-Docs 1.2.203

19 files changed, 16581 insertions, 22366 deletions

diff --git a/include/vk_video/vulkan_video_codec_h264std.h b/include/vk_video/vulkan_video_codec_h264std.h
index 3338fe1..27e4438 100644
--- a/include/vk_video/vulkan_video_codec_h264std.h
+++ b/include/vk_video/vulkan_video_codec_h264std.h
@@ -1,49 +1,53 @@
+#ifndef VULKAN_VIDEO_CODEC_H264STD_H_
+#define VULKAN_VIDEO_CODEC_H264STD_H_ 1
+
 /*
-** Copyright (c) 2019-2021 The Khronos Group Inc.
+** Copyright 2015-2021 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
 
-#ifndef VULKAN_VIDEO_CODEC_H264STD_H_
-#define VULKAN_VIDEO_CODEC_H264STD_H_ 1
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "vk_video/vulkan_video_codecs_common.h"
 
+
+#define vulkan_video_codec_h264std 1
+#include <stdint.h>
 // Vulkan 0.9 provisional Vulkan video H.264 encode and decode std specification version number
 #define VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9_5 VK_MAKE_VIDEO_STD_VERSION(0, 9, 5) // Patch version should always be set to 0
 
-// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor.
-#define VK_STD_VULKAN_VIDEO_CODEC_H264_SPEC_VERSION   VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9_5
-#define VK_STD_VULKAN_VIDEO_CODEC_H264_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264"
-
-// *************************************************
-// Video H.264 common definitions:
-// *************************************************
-
-#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32
+#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE  32
 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6
 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16
 #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 2
 #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64
+#define VK_STD_VULKAN_VIDEO_CODEC_H264_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9_5
+#define VK_STD_VULKAN_VIDEO_CODEC_H264_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264"
 
 typedef enum StdVideoH264ChromaFormatIdc {
-    STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME  = 0,
-    STD_VIDEO_H264_CHROMA_FORMAT_IDC_420         = 1,
-    STD_VIDEO_H264_CHROMA_FORMAT_IDC_422         = 2,
-    STD_VIDEO_H264_CHROMA_FORMAT_IDC_444         = 3,
-    STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID     = 0x7FFFFFFF
+    STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0,
+    STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1,
+    STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2,
+    STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3,
+    STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264ChromaFormatIdc;
 
 typedef enum StdVideoH264ProfileIdc {
-    STD_VIDEO_H264_PROFILE_IDC_BASELINE             = 66, /* Only constrained baseline is supported */
-    STD_VIDEO_H264_PROFILE_IDC_MAIN                 = 77,
-    STD_VIDEO_H264_PROFILE_IDC_HIGH                 = 100,
-    STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE  = 244,
-    STD_VIDEO_H264_PROFILE_IDC_INVALID              = 0x7FFFFFFF
+    STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66,
+    STD_VIDEO_H264_PROFILE_IDC_MAIN = 77,
+    STD_VIDEO_H264_PROFILE_IDC_HIGH = 100,
+    STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244,
+    STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264ProfileIdc;
 
 typedef enum StdVideoH264Level {
@@ -66,14 +70,16 @@ typedef enum StdVideoH264Level {
     STD_VIDEO_H264_LEVEL_6_0 = 16,
     STD_VIDEO_H264_LEVEL_6_1 = 17,
     STD_VIDEO_H264_LEVEL_6_2 = 18,
-    STD_VIDEO_H264_LEVEL_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_LEVEL_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_LEVEL_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264Level;
 
 typedef enum StdVideoH264PocType {
     STD_VIDEO_H264_POC_TYPE_0 = 0,
     STD_VIDEO_H264_POC_TYPE_1 = 1,
     STD_VIDEO_H264_POC_TYPE_2 = 2,
-    STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264PocType;
 
 typedef enum StdVideoH264AspectRatioIdc {
@@ -95,14 +101,16 @@ typedef enum StdVideoH264AspectRatioIdc {
     STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15,
     STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16,
     STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255,
-    STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264AspectRatioIdc;
 
 typedef enum StdVideoH264WeightedBipredIdc {
-    STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT  = 0,
+    STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0,
     STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1,
     STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2,
-    STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264WeightedBipredIdc;
 
 typedef enum StdVideoH264ModificationOfPicNumsIdc {
@@ -110,7 +118,8 @@ typedef enum StdVideoH264ModificationOfPicNumsIdc {
     STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1,
     STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2,
     STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3,
-    STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264ModificationOfPicNumsIdc;
 
 typedef enum StdVideoH264MemMgmtControlOp {
@@ -121,40 +130,41 @@ typedef enum StdVideoH264MemMgmtControlOp {
     STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4,
     STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5,
     STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6,
-    STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264MemMgmtControlOp;
 
 typedef enum StdVideoH264CabacInitIdc {
     STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0,
     STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1,
     STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2,
-    STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264CabacInitIdc;
 
 typedef enum StdVideoH264DisableDeblockingFilterIdc {
     STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0,
     STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1,
     STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2,
-    STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264DisableDeblockingFilterIdc;
 
 typedef enum StdVideoH264SliceType {
-    STD_VIDEO_H264_SLICE_TYPE_P  = 0,
-    STD_VIDEO_H264_SLICE_TYPE_B  = 1,
-    STD_VIDEO_H264_SLICE_TYPE_I  = 2,
-    // reserved STD_VIDEO_H264_SLICE_TYPE_SP = 3,
-    // reserved STD_VIDEO_H264_SLICE_TYPE_SI = 4,
-    STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_SLICE_TYPE_P = 0,
+    STD_VIDEO_H264_SLICE_TYPE_B = 1,
+    STD_VIDEO_H264_SLICE_TYPE_I = 2,
+    STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264SliceType;
 
 typedef enum StdVideoH264PictureType {
-    STD_VIDEO_H264_PICTURE_TYPE_P   = 0,
-    STD_VIDEO_H264_PICTURE_TYPE_B   = 1,
-    STD_VIDEO_H264_PICTURE_TYPE_I   = 2,
-    // reserved STD_VIDEO_H264_PICTURE_TYPE_SP  = 3,
-    // reserved STD_VIDEO_H264_PICTURE_TYPE_SI  = 4,
+    STD_VIDEO_H264_PICTURE_TYPE_P = 0,
+    STD_VIDEO_H264_PICTURE_TYPE_B = 1,
+    STD_VIDEO_H264_PICTURE_TYPE_I = 2,
     STD_VIDEO_H264_PICTURE_TYPE_IDR = 5,
-    STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264PictureType;
 
 typedef enum StdVideoH264NonVclNaluType {
@@ -165,148 +175,134 @@ typedef enum StdVideoH264NonVclNaluType {
     STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4,
     STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5,
     STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6,
-    STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH264NonVclNaluType;
-
 typedef struct StdVideoH264SpsVuiFlags {
-    uint32_t aspect_ratio_info_present_flag : 1;
-    uint32_t overscan_info_present_flag : 1;
-    uint32_t overscan_appropriate_flag : 1;
-    uint32_t video_signal_type_present_flag : 1;
-    uint32_t video_full_range_flag : 1;
-    uint32_t color_description_present_flag : 1;
-    uint32_t chroma_loc_info_present_flag : 1;
-    uint32_t timing_info_present_flag : 1;
-    uint32_t fixed_frame_rate_flag : 1;
-    uint32_t bitstream_restriction_flag : 1;
-    uint32_t nal_hrd_parameters_present_flag : 1;
-    uint32_t vcl_hrd_parameters_present_flag : 1;
+    uint32_t    aspect_ratio_info_present_flag : 1;
+    uint32_t    overscan_info_present_flag : 1;
+    uint32_t    overscan_appropriate_flag : 1;
+    uint32_t    video_signal_type_present_flag : 1;
+    uint32_t    video_full_range_flag : 1;
+    uint32_t    color_description_present_flag : 1;
+    uint32_t    chroma_loc_info_present_flag : 1;
+    uint32_t    timing_info_present_flag : 1;
+    uint32_t    fixed_frame_rate_flag : 1;
+    uint32_t    bitstream_restriction_flag : 1;
+    uint32_t    nal_hrd_parameters_present_flag : 1;
+    uint32_t    vcl_hrd_parameters_present_flag : 1;
 } StdVideoH264SpsVuiFlags;
 
-typedef struct StdVideoH264HrdParameters { // hrd_parameters
-    uint8_t                    cpb_cnt_minus1;
-    uint8_t                    bit_rate_scale;
-    uint8_t                    cpb_size_scale;
-    uint32_t                   bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; // cpb_cnt_minus1 number of valid elements
-    uint32_t                   cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; // cpb_cnt_minus1 number of valid elements
-    uint8_t                    cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE];              // cpb_cnt_minus1 number of valid elements
-    uint32_t                   initial_cpb_removal_delay_length_minus1;
-    uint32_t                   cpb_removal_delay_length_minus1;
-    uint32_t                   dpb_output_delay_length_minus1;
-    uint32_t                   time_offset_length;
+typedef struct StdVideoH264HrdParameters {
+    uint8_t     cpb_cnt_minus1;
+    uint8_t     bit_rate_scale;
+    uint8_t     cpb_size_scale;
+    uint32_t    bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE];
+    uint32_t    cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE];
+    uint8_t     cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE];
+    uint32_t    initial_cpb_removal_delay_length_minus1;
+    uint32_t    cpb_removal_delay_length_minus1;
+    uint32_t    dpb_output_delay_length_minus1;
+    uint32_t    time_offset_length;
 } StdVideoH264HrdParameters;
 
 typedef struct StdVideoH264SequenceParameterSetVui {
-    StdVideoH264AspectRatioIdc  aspect_ratio_idc;
-    uint16_t                    sar_width;
-    uint16_t                    sar_height;
-    uint8_t                     video_format;
-    uint8_t                     color_primaries;
-    uint8_t                     transfer_characteristics;
-    uint8_t                     matrix_coefficients;
-    uint32_t                    num_units_in_tick;
-    uint32_t                    time_scale;
-    StdVideoH264HrdParameters*  pHrdParameters;    // must be a valid ptr to hrd_parameters, if nal_hrd_parameters_present_flag or vcl_hrd_parameters_present_flag are set
-    uint8_t                     max_num_reorder_frames;
-    uint8_t                     max_dec_frame_buffering;
-    StdVideoH264SpsVuiFlags     flags;
+    StdVideoH264AspectRatioIdc    aspect_ratio_idc;
+    uint16_t                      sar_width;
+    uint16_t                      sar_height;
+    uint8_t                       video_format;
+    uint8_t                       color_primaries;
+    uint8_t                       transfer_characteristics;
+    uint8_t                       matrix_coefficients;
+    uint32_t                      num_units_in_tick;
+    uint32_t                      time_scale;
+    StdVideoH264HrdParameters*    pHrdParameters;
+    uint8_t                       max_num_reorder_frames;
+    uint8_t                       max_dec_frame_buffering;
+    StdVideoH264SpsVuiFlags       flags;
 } StdVideoH264SequenceParameterSetVui;
 
 typedef struct StdVideoH264SpsFlags {
-    uint32_t constraint_set0_flag : 1;
-    uint32_t constraint_set1_flag : 1;
-    uint32_t constraint_set2_flag : 1;
-    uint32_t constraint_set3_flag : 1;
-    uint32_t constraint_set4_flag : 1;
-    uint32_t constraint_set5_flag : 1;
-    uint32_t direct_8x8_inference_flag : 1;
-    uint32_t mb_adaptive_frame_field_flag : 1;
-    uint32_t frame_mbs_only_flag : 1;
-    uint32_t delta_pic_order_always_zero_flag : 1;
-    uint32_t separate_colour_plane_flag : 1;
-    uint32_t gaps_in_frame_num_value_allowed_flag : 1;
-    uint32_t qpprime_y_zero_transform_bypass_flag : 1;
-    uint32_t frame_cropping_flag : 1;
-    uint32_t seq_scaling_matrix_present_flag : 1;
-    uint32_t vui_parameters_present_flag : 1;
+    uint32_t    constraint_set0_flag : 1;
+    uint32_t    constraint_set1_flag : 1;
+    uint32_t    constraint_set2_flag : 1;
+    uint32_t    constraint_set3_flag : 1;
+    uint32_t    constraint_set4_flag : 1;
+    uint32_t    constraint_set5_flag : 1;
+    uint32_t    direct_8x8_inference_flag : 1;
+    uint32_t    mb_adaptive_frame_field_flag : 1;
+    uint32_t    frame_mbs_only_flag : 1;
+    uint32_t    delta_pic_order_always_zero_flag : 1;
+    uint32_t    separate_colour_plane_flag : 1;
+    uint32_t    gaps_in_frame_num_value_allowed_flag : 1;
+    uint32_t    qpprime_y_zero_transform_bypass_flag : 1;
+    uint32_t    frame_cropping_flag : 1;
+    uint32_t    seq_scaling_matrix_present_flag : 1;
+    uint32_t    vui_parameters_present_flag : 1;
 } StdVideoH264SpsFlags;
 
-typedef struct StdVideoH264ScalingLists
-{
-    // scaling_list_present_mask has one bit for each
-    // seq_scaling_list_present_flag[i] for SPS OR
-    // pic_scaling_list_present_flag[i] for PPS,
-    // bit 0 - 5 are for each entry of ScalingList4x4
-    // bit 6 - 7 are for each entry plus 6 for ScalingList8x8
-    uint8_t scaling_list_present_mask;
-    // use_default_scaling_matrix_mask has one bit for each
-    // UseDefaultScalingMatrix4x4Flag[ i ] and
-    // UseDefaultScalingMatrix8x8Flag[ i - 6 ] for SPS OR PPS
-    // bit 0 - 5 are for each entry of ScalingList4x4
-    // bit 6 - 7 are for each entry plus 6 for ScalingList8x8
-    uint8_t use_default_scaling_matrix_mask;
-    uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS];
-    uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS];
+typedef struct StdVideoH264ScalingLists {
+    uint8_t    scaling_list_present_mask;
+    uint8_t    use_default_scaling_matrix_mask;
+    uint8_t    ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS];
+    uint8_t    ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS];
 } StdVideoH264ScalingLists;
 
-typedef struct StdVideoH264SequenceParameterSet
-{
-    StdVideoH264ProfileIdc               profile_idc;
-    StdVideoH264Level                    level_idc;
-    uint8_t                              seq_parameter_set_id;
-    StdVideoH264ChromaFormatIdc          chroma_format_idc;
-    uint8_t                              bit_depth_luma_minus8;
-    uint8_t                              bit_depth_chroma_minus8;
-    uint8_t                              log2_max_frame_num_minus4;
-    StdVideoH264PocType                  pic_order_cnt_type;
-    uint8_t                              log2_max_pic_order_cnt_lsb_minus4;
-    int32_t                              offset_for_non_ref_pic;
-    int32_t                              offset_for_top_to_bottom_field;
-    uint8_t                              num_ref_frames_in_pic_order_cnt_cycle;
-    uint8_t                              max_num_ref_frames;
-    uint32_t                             pic_width_in_mbs_minus1;
-    uint32_t                             pic_height_in_map_units_minus1;
-    uint32_t                             frame_crop_left_offset;
-    uint32_t                             frame_crop_right_offset;
-    uint32_t                             frame_crop_top_offset;
-    uint32_t                             frame_crop_bottom_offset;
-    StdVideoH264SpsFlags                 flags;
-    // pOffsetForRefFrame is a pointer representing the offset_for_ref_frame array with num_ref_frames_in_pic_order_cnt_cycle number of elements
-    // If pOffsetForRefFrame has nullptr value, then num_ref_frames_in_pic_order_cnt_cycle must also be "0".
-    int32_t*                             pOffsetForRefFrame;
-    StdVideoH264ScalingLists*            pScalingLists;             // Must be a valid pointer if seq_scaling_matrix_present_flag is set
-    StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui;  // Must be a valid pointer if StdVideoH264SpsFlags:vui_parameters_present_flag is set
+typedef struct StdVideoH264SequenceParameterSet {
+    StdVideoH264ProfileIdc                  profile_idc;
+    StdVideoH264Level                       level_idc;
+    uint8_t                                 seq_parameter_set_id;
+    StdVideoH264ChromaFormatIdc             chroma_format_idc;
+    uint8_t                                 bit_depth_luma_minus8;
+    uint8_t                                 bit_depth_chroma_minus8;
+    uint8_t                                 log2_max_frame_num_minus4;
+    StdVideoH264PocType                     pic_order_cnt_type;
+    uint8_t                                 log2_max_pic_order_cnt_lsb_minus4;
+    int32_t                                 offset_for_non_ref_pic;
+    int32_t                                 offset_for_top_to_bottom_field;
+    uint8_t                                 num_ref_frames_in_pic_order_cnt_cycle;
+    uint8_t                                 max_num_ref_frames;
+    uint32_t                                pic_width_in_mbs_minus1;
+    uint32_t                                pic_height_in_map_units_minus1;
+    uint32_t                                frame_crop_left_offset;
+    uint32_t                                frame_crop_right_offset;
+    uint32_t                                frame_crop_top_offset;
+    uint32_t                                frame_crop_bottom_offset;
+    StdVideoH264SpsFlags                    flags;
+    int32_t*                                pOffsetForRefFrame;
+    StdVideoH264ScalingLists*               pScalingLists;
+    StdVideoH264SequenceParameterSetVui*    pSequenceParameterSetVui;
 } StdVideoH264SequenceParameterSet;
 
 typedef struct StdVideoH264PpsFlags {
-    uint32_t transform_8x8_mode_flag : 1;
-    uint32_t redundant_pic_cnt_present_flag : 1;
-    uint32_t constrained_intra_pred_flag : 1;
-    uint32_t deblocking_filter_control_present_flag : 1;
-    uint32_t weighted_bipred_idc_flag : 1;
-    uint32_t weighted_pred_flag : 1;
-    uint32_t pic_order_present_flag : 1;
-    uint32_t entropy_coding_mode_flag : 1;
-    uint32_t pic_scaling_matrix_present_flag : 1;
+    uint32_t    transform_8x8_mode_flag : 1;
+    uint32_t    redundant_pic_cnt_present_flag : 1;
+    uint32_t    constrained_intra_pred_flag : 1;
+    uint32_t    deblocking_filter_control_present_flag : 1;
+    uint32_t    weighted_bipred_idc_flag : 1;
+    uint32_t    weighted_pred_flag : 1;
+    uint32_t    pic_order_present_flag : 1;
+    uint32_t    entropy_coding_mode_flag : 1;
+    uint32_t    pic_scaling_matrix_present_flag : 1;
 } StdVideoH264PpsFlags;
 
-typedef struct StdVideoH264PictureParameterSet
-{
-    uint8_t                       seq_parameter_set_id;
-    uint8_t                       pic_parameter_set_id;
-    uint8_t                       num_ref_idx_l0_default_active_minus1;
-    uint8_t                       num_ref_idx_l1_default_active_minus1;
-    StdVideoH264WeightedBipredIdc weighted_bipred_idc;
-    int8_t                        pic_init_qp_minus26;
-    int8_t                        pic_init_qs_minus26;
-    int8_t                        chroma_qp_index_offset;
-    int8_t                        second_chroma_qp_index_offset;
-    StdVideoH264PpsFlags          flags;
-    StdVideoH264ScalingLists*     pScalingLists; // Must be a valid pointer if  StdVideoH264PpsFlags::pic_scaling_matrix_present_flag is set.
+typedef struct StdVideoH264PictureParameterSet {
+    uint8_t                          seq_parameter_set_id;
+    uint8_t                          pic_parameter_set_id;
+    uint8_t                          num_ref_idx_l0_default_active_minus1;
+    uint8_t                          num_ref_idx_l1_default_active_minus1;
+    StdVideoH264WeightedBipredIdc    weighted_bipred_idc;
+    int8_t                           pic_init_qp_minus26;
+    int8_t                           pic_init_qs_minus26;
+    int8_t                           chroma_qp_index_offset;
+    int8_t                           second_chroma_qp_index_offset;
+    StdVideoH264PpsFlags             flags;
+    StdVideoH264ScalingLists*        pScalingLists;
 } StdVideoH264PictureParameterSet;
 
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif // VULKAN_VIDEO_CODEC_H264STD_H_
+#endif
diff --git a/include/vk_video/vulkan_video_codec_h264std_decode.h b/include/vk_video/vulkan_video_codec_h264std_decode.h
index cb0d1df..dda6009 100644
--- a/include/vk_video/vulkan_video_codec_h264std_decode.h
+++ b/include/vk_video/vulkan_video_codec_h264std_decode.h
@@ -1,92 +1,93 @@
+#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_
+#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
+
 /*
-** Copyright (c) 2019-2020 The Khronos Group Inc.
+** Copyright 2015-2021 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
 
-#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_
-#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "vk_video/vulkan_video_codec_h264std.h"
 
-// *************************************************
-// Video H.264 Decode related parameters:
-// *************************************************
 
+#define vulkan_video_codec_h264std_decode 1
+#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2
 #define STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE 15
 
 typedef enum StdVideoDecodeH264FieldOrderCount {
-    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP       = 0,
-    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM    = 1,
-    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE = 2,
-    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID   = 0x7FFFFFFF
-} StdVideoDecodeH264FieldOrderCnt;
-
+    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0,
+    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1,
+    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF
+} StdVideoDecodeH264FieldOrderCount;
 typedef struct StdVideoDecodeH264PictureInfoFlags {
-    uint32_t field_pic_flag : 1;             // Is field picture
-    uint32_t is_intra : 1;                   // Is intra picture
-    uint32_t IdrPicFlag : 1;                 // instantaneous decoding refresh (IDR) picture
-    uint32_t bottom_field_flag : 1;          // bottom (true) or top (false) field if field_pic_flag is set.
-    uint32_t is_reference : 1;               // This only applies to picture info, and not to the DPB lists.
-    uint32_t complementary_field_pair : 1;   // complementary field pair, complementary non-reference field pair, complementary reference field pair
+    uint32_t    field_pic_flag : 1;
+    uint32_t    is_intra : 1;
+    uint32_t    IdrPicFlag : 1;
+    uint32_t    bottom_field_flag : 1;
+    uint32_t    is_reference : 1;
+    uint32_t    complementary_field_pair : 1;
 } StdVideoDecodeH264PictureInfoFlags;
 
 typedef struct StdVideoDecodeH264PictureInfo {
-    uint8_t  seq_parameter_set_id;          // Selecting SPS from the Picture Parameters
-    uint8_t  pic_parameter_set_id;          // Selecting PPS from the Picture Parameters and the SPS
-    uint16_t reserved;                      // for structure members 32-bit packing/alignment
-    uint16_t frame_num;                     // 7.4.3 Slice header semantics
-    uint16_t idr_pic_id;                    // 7.4.3 Slice header semantics
-    // PicOrderCnt is based on TopFieldOrderCnt and BottomFieldOrderCnt. See 8.2.1 Decoding process for picture order count type 0 - 2
-    int32_t  PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE];  // TopFieldOrderCnt and BottomFieldOrderCnt fields.
-    StdVideoDecodeH264PictureInfoFlags flags;
+    uint8_t                               seq_parameter_set_id;
+    uint8_t                               pic_parameter_set_id;
+    uint16_t                              reserved;
+    uint16_t                              frame_num;
+    uint16_t                              idr_pic_id;
+    int32_t                               PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE];
+    StdVideoDecodeH264PictureInfoFlags    flags;
 } StdVideoDecodeH264PictureInfo;
 
 typedef struct StdVideoDecodeH264ReferenceInfoFlags {
-    uint32_t top_field_flag : 1;             // Reference is used for top field reference.
-    uint32_t bottom_field_flag : 1;          // Reference is used for bottom field reference.
-    uint32_t is_long_term : 1;               // this is a long term reference
-    uint32_t is_non_existing : 1;            // Must be handled in accordance with 8.2.5.2: Decoding process for gaps in frame_num
+    uint32_t    top_field_flag : 1;
+    uint32_t    bottom_field_flag : 1;
+    uint32_t    is_long_term : 1;
+    uint32_t    is_non_existing : 1;
 } StdVideoDecodeH264ReferenceInfoFlags;
 
 typedef struct StdVideoDecodeH264ReferenceInfo {
-    // FrameNum = is_long_term ?  long_term_frame_idx : frame_num
-    uint16_t FrameNum;                     // 7.4.3.3 Decoded reference picture marking semantics
-    uint16_t reserved;                     // for structure members 32-bit packing/alignment
-    int32_t  PicOrderCnt[2];               // TopFieldOrderCnt and BottomFieldOrderCnt fields.
-    StdVideoDecodeH264ReferenceInfoFlags flags;
+    uint16_t                                FrameNum;
+    uint16_t                                reserved;
+    int32_t                                 PicOrderCnt[2];
+    StdVideoDecodeH264ReferenceInfoFlags    flags;
 } StdVideoDecodeH264ReferenceInfo;
 
 typedef struct StdVideoDecodeH264MvcElementFlags {
-    uint32_t non_idr : 1;
-    uint32_t anchor_pic : 1;
-    uint32_t inter_view : 1;
+    uint32_t    non_idr : 1;
+    uint32_t    anchor_pic : 1;
+    uint32_t    inter_view : 1;
 } StdVideoDecodeH264MvcElementFlags;
 
 typedef struct StdVideoDecodeH264MvcElement {
-    StdVideoDecodeH264MvcElementFlags flags;
-    uint16_t viewOrderIndex;
-    uint16_t viewId;
-    uint16_t temporalId; // move out?
-    uint16_t priorityId; // move out?
-    uint16_t numOfAnchorRefsInL0;
-    uint16_t viewIdOfAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
-    uint16_t numOfAnchorRefsInL1;
-    uint16_t viewIdOfAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
-    uint16_t numOfNonAnchorRefsInL0;
-    uint16_t viewIdOfNonAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
-    uint16_t numOfNonAnchorRefsInL1;
-    uint16_t viewIdOfNonAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
+    StdVideoDecodeH264MvcElementFlags    flags;
+    uint16_t                             viewOrderIndex;
+    uint16_t                             viewId;
+    uint16_t                             temporalId;
+    uint16_t                             priorityId;
+    uint16_t                             numOfAnchorRefsInL0;
+    uint16_t                             viewIdOfAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
+    uint16_t                             numOfAnchorRefsInL1;
+    uint16_t                             viewIdOfAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
+    uint16_t                             numOfNonAnchorRefsInL0;
+    uint16_t                             viewIdOfNonAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
+    uint16_t                             numOfNonAnchorRefsInL1;
+    uint16_t                             viewIdOfNonAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE];
 } StdVideoDecodeH264MvcElement;
 
 typedef struct StdVideoDecodeH264Mvc {
-    uint32_t viewId0;
-    uint32_t mvcElementCount;
-    StdVideoDecodeH264MvcElement* pMvcElements;
+    uint32_t                         viewId0;
+    uint32_t                         mvcElementCount;
+    StdVideoDecodeH264MvcElement*    pMvcElements;
 } StdVideoDecodeH264Mvc;
 
 
@@ -94,4 +95,4 @@ typedef struct StdVideoDecodeH264Mvc {
 }
 #endif
 
-#endif // VULKAN_VIDEO_CODEC_H264STD_DECODE_H_
+#endif
diff --git a/include/vk_video/vulkan_video_codec_h264std_encode.h b/include/vk_video/vulkan_video_codec_h264std_encode.h
index f3a0d3a..4387908 100644
--- a/include/vk_video/vulkan_video_codec_h264std_encode.h
+++ b/include/vk_video/vulkan_video_codec_h264std_encode.h
@@ -1,89 +1,92 @@
+#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_
+#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
+
 /*
-** Copyright (c) 2019-2021 The Khronos Group Inc.
+** Copyright 2015-2021 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
 
-#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_
-#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "vk_video/vulkan_video_codec_h264std.h"
 
-// *************************************************
-// Video H.264 Encode related parameters:
-// *************************************************
 
+#define vulkan_video_codec_h264std_encode 1
 typedef struct StdVideoEncodeH264SliceHeaderFlags {
-    uint32_t idr_flag : 1;
-    uint32_t is_reference_flag : 1;
-    uint32_t num_ref_idx_active_override_flag : 1;
-    uint32_t no_output_of_prior_pics_flag : 1;
-    uint32_t long_term_reference_flag : 1;
-    uint32_t adaptive_ref_pic_marking_mode_flag : 1;
-    uint32_t no_prior_references_available_flag : 1;
+    uint32_t    idr_flag : 1;
+    uint32_t    is_reference_flag : 1;
+    uint32_t    num_ref_idx_active_override_flag : 1;
+    uint32_t    no_output_of_prior_pics_flag : 1;
+    uint32_t    long_term_reference_flag : 1;
+    uint32_t    adaptive_ref_pic_marking_mode_flag : 1;
+    uint32_t    no_prior_references_available_flag : 1;
 } StdVideoEncodeH264SliceHeaderFlags;
 
 typedef struct StdVideoEncodeH264PictureInfoFlags {
-    uint32_t idr_flag : 1;
-    uint32_t is_reference_flag : 1;
-    uint32_t long_term_reference_flag : 1;
+    uint32_t    idr_flag : 1;
+    uint32_t    is_reference_flag : 1;
+    uint32_t    long_term_reference_flag : 1;
 } StdVideoEncodeH264PictureInfoFlags;
 
 typedef struct StdVideoEncodeH264RefMgmtFlags {
-    uint32_t ref_pic_list_modification_l0_flag : 1;
-    uint32_t ref_pic_list_modification_l1_flag : 1;
+    uint32_t    ref_pic_list_modification_l0_flag : 1;
+    uint32_t    ref_pic_list_modification_l1_flag : 1;
 } StdVideoEncodeH264RefMgmtFlags;
 
 typedef struct StdVideoEncodeH264RefListModEntry {
-    StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc;
-    uint16_t                             abs_diff_pic_num_minus1;
-    uint16_t                             long_term_pic_num;
+    StdVideoH264ModificationOfPicNumsIdc    modification_of_pic_nums_idc;
+    uint16_t                                abs_diff_pic_num_minus1;
+    uint16_t                                long_term_pic_num;
 } StdVideoEncodeH264RefListModEntry;
 
 typedef struct StdVideoEncodeH264RefPicMarkingEntry {
-    StdVideoH264MemMgmtControlOp  operation;
-    uint16_t                      difference_of_pic_nums_minus1;
-    uint16_t                      long_term_pic_num;
-    uint16_t                      long_term_frame_idx;
-    uint16_t                      max_long_term_frame_idx_plus1;
+    StdVideoH264MemMgmtControlOp    operation;
+    uint16_t                        difference_of_pic_nums_minus1;
+    uint16_t                        long_term_pic_num;
+    uint16_t                        long_term_frame_idx;
+    uint16_t                        max_long_term_frame_idx_plus1;
 } StdVideoEncodeH264RefPicMarkingEntry;
 
 typedef struct StdVideoEncodeH264RefMemMgmtCtrlOperations {
-    StdVideoEncodeH264RefMgmtFlags        flags;
-    uint8_t                               refList0ModOpCount;
-    StdVideoEncodeH264RefListModEntry*    pRefList0ModOperations;
-    uint8_t                               refList1ModOpCount;
-    StdVideoEncodeH264RefListModEntry*    pRefList1ModOperations;
-    uint8_t                               refPicMarkingOpCount;
-    StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations;
+    StdVideoEncodeH264RefMgmtFlags           flags;
+    uint8_t                                  refList0ModOpCount;
+    StdVideoEncodeH264RefListModEntry*       pRefList0ModOperations;
+    uint8_t                                  refList1ModOpCount;
+    StdVideoEncodeH264RefListModEntry*       pRefList1ModOperations;
+    uint8_t                                  refPicMarkingOpCount;
+    StdVideoEncodeH264RefPicMarkingEntry*    pRefPicMarkingOperations;
 } StdVideoEncodeH264RefMemMgmtCtrlOperations;
 
 typedef struct StdVideoEncodeH264PictureInfo {
-    StdVideoEncodeH264PictureInfoFlags   flags;
-    StdVideoH264PictureType              pictureType;
-    uint32_t                             frameNum;
-    uint32_t                             pictureOrderCount;
-    uint16_t                             long_term_pic_num;
-    uint16_t                             long_term_frame_idx;
+    StdVideoEncodeH264PictureInfoFlags    flags;
+    StdVideoH264PictureType               pictureType;
+    uint32_t                              frameNum;
+    uint32_t                              pictureOrderCount;
+    uint16_t                              long_term_pic_num;
+    uint16_t                              long_term_frame_idx;
 } StdVideoEncodeH264PictureInfo;
 
 typedef struct StdVideoEncodeH264SliceHeader {
-    StdVideoEncodeH264SliceHeaderFlags          flags;
-    StdVideoH264SliceType                       slice_type;
-    uint8_t                                     seq_parameter_set_id;
-    uint8_t                                     pic_parameter_set_id;
-    uint16_t                                    idr_pic_id;
-    uint8_t                                     num_ref_idx_l0_active_minus1;
-    uint8_t                                     num_ref_idx_l1_active_minus1;
-    StdVideoH264CabacInitIdc                    cabac_init_idc;
-    StdVideoH264DisableDeblockingFilterIdc      disable_deblocking_filter_idc;
-    int8_t                                      slice_alpha_c0_offset_div2;
-    int8_t                                      slice_beta_offset_div2;
-    StdVideoEncodeH264RefMemMgmtCtrlOperations* pMemMgmtCtrlOperations;
+    StdVideoEncodeH264SliceHeaderFlags             flags;
+    StdVideoH264SliceType                          slice_type;
+    uint8_t                                        seq_parameter_set_id;
+    uint8_t                                        pic_parameter_set_id;
+    uint16_t                                       idr_pic_id;
+    uint8_t                                        num_ref_idx_l0_active_minus1;
+    uint8_t                                        num_ref_idx_l1_active_minus1;
+    StdVideoH264CabacInitIdc                       cabac_init_idc;
+    StdVideoH264DisableDeblockingFilterIdc         disable_deblocking_filter_idc;
+    int8_t                                         slice_alpha_c0_offset_div2;
+    int8_t                                         slice_beta_offset_div2;
+    StdVideoEncodeH264RefMemMgmtCtrlOperations*    pMemMgmtCtrlOperations;
 } StdVideoEncodeH264SliceHeader;
 
 
@@ -91,4 +94,4 @@ typedef struct StdVideoEncodeH264SliceHeader {
 }
 #endif
 
-#endif // VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_
+#endif
diff --git a/include/vk_video/vulkan_video_codec_h265std.h b/include/vk_video/vulkan_video_codec_h265std.h
index 179c6b7..5690f36 100644
--- a/include/vk_video/vulkan_video_codec_h265std.h
+++ b/include/vk_video/vulkan_video_codec_h265std.h
@@ -1,27 +1,30 @@
+#ifndef VULKAN_VIDEO_CODEC_H265STD_H_
+#define VULKAN_VIDEO_CODEC_H265STD_H_ 1
+
 /*
-** Copyright (c) 2019-2021 The Khronos Group Inc.
+** Copyright 2015-2021 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
 
-#ifndef VULKAN_VIDEO_CODEC_H265STD_H_
-#define VULKAN_VIDEO_CODEC_H265STD_H_ 1
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "vk_video/vulkan_video_codecs_common.h"
 
+
+#define vulkan_video_codec_h265std 1
 // Vulkan 0.5 version number WIP
 #define VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_9_5 VK_MAKE_VIDEO_STD_VERSION(0, 9, 5) // Patch version should always be set to 0
 
-// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor.
-#define VK_STD_VULKAN_VIDEO_CODEC_H265_SPEC_VERSION   VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_9_5
-#define VK_STD_VULKAN_VIDEO_CODEC_H265_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265"
-
-#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32
 #define STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE 7
+#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE  32
 #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6
 #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16
 #define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6
@@ -30,27 +33,31 @@ extern "C" {
 #define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64
 #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2
 #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21
 #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3
 #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6
+#define VK_STD_VULKAN_VIDEO_CODEC_H265_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_9_5
+#define VK_STD_VULKAN_VIDEO_CODEC_H265_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265"
 
 typedef enum StdVideoH265ChromaFormatIdc {
-    STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME  = 0,
-    STD_VIDEO_H265_CHROMA_FORMAT_IDC_420         = 1,
-    STD_VIDEO_H265_CHROMA_FORMAT_IDC_422         = 2,
-    STD_VIDEO_H265_CHROMA_FORMAT_IDC_444         = 3,
-    STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID     = 0x7FFFFFFF
+    STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0,
+    STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1,
+    STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2,
+    STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3,
+    STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH265ChromaFormatIdc;
 
 typedef enum StdVideoH265ProfileIdc {
-    STD_VIDEO_H265_PROFILE_IDC_MAIN                     = 1,
-    STD_VIDEO_H265_PROFILE_IDC_MAIN_10                  = 2,
-    STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE       = 3,
-    STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS  = 4,
-    STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS           = 9,
-    STD_VIDEO_H265_PROFILE_IDC_INVALID                  = 0x7FFFFFFF
+    STD_VIDEO_H265_PROFILE_IDC_MAIN = 1,
+    STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2,
+    STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3,
+    STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4,
+    STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9,
+    STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH265ProfileIdc;
 
 typedef enum StdVideoH265Level {
@@ -67,305 +74,287 @@ typedef enum StdVideoH265Level {
     STD_VIDEO_H265_LEVEL_6_0 = 10,
     STD_VIDEO_H265_LEVEL_6_1 = 11,
     STD_VIDEO_H265_LEVEL_6_2 = 12,
-    STD_VIDEO_H265_LEVEL_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H265_LEVEL_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H265_LEVEL_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH265Level;
 
 typedef enum StdVideoH265SliceType {
     STD_VIDEO_H265_SLICE_TYPE_B = 0,
     STD_VIDEO_H265_SLICE_TYPE_P = 1,
     STD_VIDEO_H265_SLICE_TYPE_I = 2,
-    STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH265SliceType;
 
 typedef enum StdVideoH265PictureType {
-    STD_VIDEO_H265_PICTURE_TYPE_P   = 0,
-    STD_VIDEO_H265_PICTURE_TYPE_B   = 1,
-    STD_VIDEO_H265_PICTURE_TYPE_I   = 2,
+    STD_VIDEO_H265_PICTURE_TYPE_P = 0,
+    STD_VIDEO_H265_PICTURE_TYPE_B = 1,
+    STD_VIDEO_H265_PICTURE_TYPE_I = 2,
     STD_VIDEO_H265_PICTURE_TYPE_IDR = 3,
-    STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF
+    STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } StdVideoH265PictureType;
-
-typedef struct StdVideoH265DecPicBufMgr
-{
-    uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
-    uint8_t  max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
-    uint8_t  max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
+typedef struct StdVideoH265DecPicBufMgr {
+    uint32_t    max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
+    uint8_t     max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
+    uint8_t     max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
 } StdVideoH265DecPicBufMgr;
 
-typedef struct StdVideoH265SubLayerHrdParameters { // sub_layer_hrd_parameters
-    uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
-    uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
-    uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
-    uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
-    uint32_t cbr_flag; // each bit represents a range of CpbCounts (bit 0 - cpb_cnt_minus1) per sub-layer
+typedef struct StdVideoH265SubLayerHrdParameters {
+    uint32_t    bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
+    uint32_t    cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
+    uint32_t    cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
+    uint32_t    bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE];
+    uint32_t    cbr_flag;
 } StdVideoH265SubLayerHrdParameters;
 
 typedef struct StdVideoH265HrdFlags {
-    uint32_t nal_hrd_parameters_present_flag : 1;
-    uint32_t vcl_hrd_parameters_present_flag : 1;
-    uint32_t sub_pic_hrd_params_present_flag : 1;
-    uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1;
-    uint32_t fixed_pic_rate_general_flag : 8;    // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1
-    uint32_t fixed_pic_rate_within_cvs_flag : 8; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1
-    uint32_t low_delay_hrd_flag : 8;             // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1
+    uint32_t    nal_hrd_parameters_present_flag : 1;
+    uint32_t    vcl_hrd_parameters_present_flag : 1;
+    uint32_t    sub_pic_hrd_params_present_flag : 1;
+    uint32_t    sub_pic_cpb_params_in_pic_timing_sei_flag : 1;
+    uint32_t    fixed_pic_rate_general_flag : 8;
+    uint32_t    fixed_pic_rate_within_cvs_flag : 8;
+    uint32_t    low_delay_hrd_flag : 8;
 } StdVideoH265HrdFlags;
 
 typedef struct StdVideoH265HrdParameters {
-    uint8_t                            tick_divisor_minus2;
-    uint8_t                            du_cpb_removal_delay_increment_length_minus1;
-    uint8_t                            dpb_output_delay_du_length_minus1;
-    uint8_t                            bit_rate_scale;
-    uint8_t                            cpb_size_scale;
-    uint8_t                            cpb_size_du_scale;
-    uint8_t                            initial_cpb_removal_delay_length_minus1;
-    uint8_t                            au_cpb_removal_delay_length_minus1;
-    uint8_t                            dpb_output_delay_length_minus1;
-    uint8_t                            cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
-    uint16_t                           elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
-    StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; // NAL per layer ptr to sub_layer_hrd_parameters
-    StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; // VCL per layer ptr to sub_layer_hrd_parameters
-    StdVideoH265HrdFlags               flags;
+    uint8_t                               tick_divisor_minus2;
+    uint8_t                               du_cpb_removal_delay_increment_length_minus1;
+    uint8_t                               dpb_output_delay_du_length_minus1;
+    uint8_t                               bit_rate_scale;
+    uint8_t                               cpb_size_scale;
+    uint8_t                               cpb_size_du_scale;
+    uint8_t                               initial_cpb_removal_delay_length_minus1;
+    uint8_t                               au_cpb_removal_delay_length_minus1;
+    uint8_t                               dpb_output_delay_length_minus1;
+    uint8_t                               cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
+    uint16_t                              elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
+    StdVideoH265SubLayerHrdParameters*    pSubLayerHrdParametersNal[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
+    StdVideoH265SubLayerHrdParameters*    pSubLayerHrdParametersVcl[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE];
+    StdVideoH265HrdFlags                  flags;
 } StdVideoH265HrdParameters;
 
 typedef struct StdVideoH265VpsFlags {
-    uint32_t vps_temporal_id_nesting_flag : 1;
-    uint32_t vps_sub_layer_ordering_info_present_flag : 1;
-    uint32_t vps_timing_info_present_flag : 1;
-    uint32_t vps_poc_proportional_to_timing_flag : 1;
+    uint32_t    vps_temporal_id_nesting_flag : 1;
+    uint32_t    vps_sub_layer_ordering_info_present_flag : 1;
+    uint32_t    vps_timing_info_present_flag : 1;
+    uint32_t    vps_poc_proportional_to_timing_flag : 1;
 } StdVideoH265VpsFlags;
 
-typedef struct StdVideoH265VideoParameterSet
-{
-    uint8_t                      vps_video_parameter_set_id;
-    uint8_t                      vps_max_sub_layers_minus1;
-    uint32_t                     vps_num_units_in_tick;
-    uint32_t                     vps_time_scale;
-    uint32_t                     vps_num_ticks_poc_diff_one_minus1;
-    StdVideoH265DecPicBufMgr*    pDecPicBufMgr;
-    StdVideoH265HrdParameters*   pHrdParameters;
-    StdVideoH265VpsFlags         flags;
+typedef struct StdVideoH265VideoParameterSet {
+    uint8_t                       vps_video_parameter_set_id;
+    uint8_t                       vps_max_sub_layers_minus1;
+    uint32_t                      vps_num_units_in_tick;
+    uint32_t                      vps_time_scale;
+    uint32_t                      vps_num_ticks_poc_diff_one_minus1;
+    StdVideoH265DecPicBufMgr*     pDecPicBufMgr;
+    StdVideoH265HrdParameters*    pHrdParameters;
+    StdVideoH265VpsFlags          flags;
 } StdVideoH265VideoParameterSet;
 
-typedef struct StdVideoH265ScalingLists
-{
-    uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS];       // ScalingList[ 0 ][ MatrixID ][ i ] (sizeID = 0)
-    uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS];       // ScalingList[ 1 ][ MatrixID ][ i ] (sizeID = 1)
-    uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS];     // ScalingList[ 2 ][ MatrixID ][ i ] (sizeID = 2)
-    uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS];     // ScalingList[ 3 ][ MatrixID ][ i ] (sizeID = 3)
-    uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS];   // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8, sizeID = 2
-    uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS];   // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8. sizeID = 3
+typedef struct StdVideoH265ScalingLists {
+    uint8_t    ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS];
+    uint8_t    ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS];
+    uint8_t    ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS];
+    uint8_t    ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS];
+    uint8_t    ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS];
+    uint8_t    ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS];
 } StdVideoH265ScalingLists;
 
 typedef struct StdVideoH265SpsVuiFlags {
-    uint32_t aspect_ratio_info_present_flag : 1;
-    uint32_t overscan_info_present_flag : 1;
-    uint32_t overscan_appropriate_flag : 1;
-    uint32_t video_signal_type_present_flag : 1;
-    uint32_t video_full_range_flag : 1;
-    uint32_t colour_description_present_flag : 1;
-    uint32_t chroma_loc_info_present_flag : 1;
-    uint32_t neutral_chroma_indication_flag : 1;
-    uint32_t field_seq_flag : 1;
-    uint32_t frame_field_info_present_flag : 1;
-    uint32_t default_display_window_flag : 1;
-    uint32_t vui_timing_info_present_flag : 1;
-    uint32_t vui_poc_proportional_to_timing_flag : 1;
-    uint32_t vui_hrd_parameters_present_flag : 1;
-    uint32_t bitstream_restriction_flag : 1;
-    uint32_t tiles_fixed_structure_flag : 1;
-    uint32_t motion_vectors_over_pic_boundaries_flag : 1;
-    uint32_t restricted_ref_pic_lists_flag : 1;
+    uint32_t    aspect_ratio_info_present_flag : 1;
+    uint32_t    overscan_info_present_flag : 1;
+    uint32_t    overscan_appropriate_flag : 1;
+    uint32_t    video_signal_type_present_flag : 1;
+    uint32_t    video_full_range_flag : 1;
+    uint32_t    colour_description_present_flag : 1;
+    uint32_t    chroma_loc_info_present_flag : 1;
+    uint32_t    neutral_chroma_indication_flag : 1;
+    uint32_t    field_seq_flag : 1;
+    uint32_t    frame_field_info_present_flag : 1;
+    uint32_t    default_display_window_flag : 1;
+    uint32_t    vui_timing_info_present_flag : 1;
+    uint32_t    vui_poc_proportional_to_timing_flag : 1;
+    uint32_t    vui_hrd_parameters_present_flag : 1;
+    uint32_t    bitstream_restriction_flag : 1;
+    uint32_t    tiles_fixed_structure_flag : 1;
+    uint32_t    motion_vectors_over_pic_boundaries_flag : 1;
+    uint32_t    restricted_ref_pic_lists_flag : 1;
 } StdVideoH265SpsVuiFlags;
 
 typedef struct StdVideoH265SequenceParameterSetVui {
-    uint8_t                     aspect_ratio_idc;
-    uint16_t                    sar_width;
-    uint16_t                    sar_height;
-    uint8_t                     video_format;
-    uint8_t                     colour_primaries;
-    uint8_t                     transfer_characteristics;
-    uint8_t                     matrix_coeffs;
-    uint8_t                     chroma_sample_loc_type_top_field;
-    uint8_t                     chroma_sample_loc_type_bottom_field;
-    uint16_t                    def_disp_win_left_offset;
-    uint16_t                    def_disp_win_right_offset;
-    uint16_t                    def_disp_win_top_offset;
-    uint16_t                    def_disp_win_bottom_offset;
-    uint32_t                    vui_num_units_in_tick;
-    uint32_t                    vui_time_scale;
-    uint32_t                    vui_num_ticks_poc_diff_one_minus1;
-    StdVideoH265HrdParameters*  pHrdParameters;
-    uint16_t                    min_spatial_segmentation_idc;
-    uint8_t                     max_bytes_per_pic_denom;
-    uint8_t                     max_bits_per_min_cu_denom;
-    uint8_t                     log2_max_mv_length_horizontal;
-    uint8_t                     log2_max_mv_length_vertical;
-    StdVideoH265SpsVuiFlags     flags;
+    uint8_t                       aspect_ratio_idc;
+    uint16_t                      sar_width;
+    uint16_t                      sar_height;
+    uint8_t                       video_format;
+    uint8_t                       colour_primaries;
+    uint8_t                       transfer_characteristics;
+    uint8_t                       matrix_coeffs;
+    uint8_t                       chroma_sample_loc_type_top_field;
+    uint8_t                       chroma_sample_loc_type_bottom_field;
+    uint16_t                      def_disp_win_left_offset;
+    uint16_t                      def_disp_win_right_offset;
+    uint16_t                      def_disp_win_top_offset;
+    uint16_t                      def_disp_win_bottom_offset;
+    uint32_t                      vui_num_units_in_tick;
+    uint32_t                      vui_time_scale;
+    uint32_t                      vui_num_ticks_poc_diff_one_minus1;
+    StdVideoH265HrdParameters*    pHrdParameters;
+    uint16_t                      min_spatial_segmentation_idc;
+    uint8_t                       max_bytes_per_pic_denom;
+    uint8_t                       max_bits_per_min_cu_denom;
+    uint8_t                       log2_max_mv_length_horizontal;
+    uint8_t                       log2_max_mv_length_vertical;
+    StdVideoH265SpsVuiFlags       flags;
 } StdVideoH265SequenceParameterSetVui;
 
-typedef struct StdVideoH265PredictorPaletteEntries
-{
-    uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE];
+typedef struct StdVideoH265PredictorPaletteEntries {
+    uint16_t    PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE];
 } StdVideoH265PredictorPaletteEntries;
 
 typedef struct StdVideoH265SpsFlags {
-    uint32_t sps_temporal_id_nesting_flag : 1;
-    uint32_t separate_colour_plane_flag : 1;
-    uint32_t scaling_list_enabled_flag : 1;
-    uint32_t sps_scaling_list_data_present_flag : 1;
-    uint32_t amp_enabled_flag : 1;
-    uint32_t sample_adaptive_offset_enabled_flag : 1;
-    uint32_t pcm_enabled_flag : 1;
-    uint32_t pcm_loop_filter_disabled_flag : 1;
-    uint32_t long_term_ref_pics_present_flag : 1;
-    uint32_t sps_temporal_mvp_enabled_flag : 1;
-    uint32_t strong_intra_smoothing_enabled_flag : 1;
-    uint32_t vui_parameters_present_flag : 1;
-    uint32_t sps_extension_present_flag : 1;
-    uint32_t sps_range_extension_flag : 1;
-
-    // extension SPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS is set
-    uint32_t transform_skip_rotation_enabled_flag : 1;
-    uint32_t transform_skip_context_enabled_flag : 1;
-    uint32_t implicit_rdpcm_enabled_flag : 1;
-    uint32_t explicit_rdpcm_enabled_flag : 1;
-    uint32_t extended_precision_processing_flag : 1;
-    uint32_t intra_smoothing_disabled_flag : 1;
-    uint32_t high_precision_offsets_enabled_flag : 1;
-    uint32_t persistent_rice_adaptation_enabled_flag : 1;
-    uint32_t cabac_bypass_alignment_enabled_flag : 1;
-
-    // extension SPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set
-    uint32_t sps_curr_pic_ref_enabled_flag : 1;
-    uint32_t palette_mode_enabled_flag : 1;
-    uint32_t sps_palette_predictor_initializer_present_flag : 1;
-    uint32_t intra_boundary_filtering_disabled_flag : 1;
+    uint32_t    sps_temporal_id_nesting_flag : 1;
+    uint32_t    separate_colour_plane_flag : 1;
+    uint32_t    scaling_list_enabled_flag : 1;
+    uint32_t    sps_scaling_list_data_present_flag : 1;
+    uint32_t    amp_enabled_flag : 1;
+    uint32_t    sample_adaptive_offset_enabled_flag : 1;
+    uint32_t    pcm_enabled_flag : 1;
+    uint32_t    pcm_loop_filter_disabled_flag : 1;
+    uint32_t    long_term_ref_pics_present_flag : 1;
+    uint32_t    sps_temporal_mvp_enabled_flag : 1;
+    uint32_t    strong_intra_smoothing_enabled_flag : 1;
+    uint32_t    vui_parameters_present_flag : 1;
+    uint32_t    sps_extension_present_flag : 1;
+    uint32_t    sps_range_extension_flag : 1;
+    uint32_t    transform_skip_rotation_enabled_flag : 1;
+    uint32_t    transform_skip_context_enabled_flag : 1;
+    uint32_t    implicit_rdpcm_enabled_flag : 1;
+    uint32_t    explicit_rdpcm_enabled_flag : 1;
+    uint32_t    extended_precision_processing_flag : 1;
+    uint32_t    intra_smoothing_disabled_flag : 1;
+    uint32_t    high_precision_offsets_enabled_flag : 1;
+    uint32_t    persistent_rice_adaptation_enabled_flag : 1;
+    uint32_t    cabac_bypass_alignment_enabled_flag : 1;
+    uint32_t    sps_curr_pic_ref_enabled_flag : 1;
+    uint32_t    palette_mode_enabled_flag : 1;
+    uint32_t    sps_palette_predictor_initializer_present_flag : 1;
+    uint32_t    intra_boundary_filtering_disabled_flag : 1;
 } StdVideoH265SpsFlags;
 
-typedef struct StdVideoH265SequenceParameterSet
-{
-    StdVideoH265ProfileIdc               profile_idc;
-    StdVideoH265Level                    level_idc;
-    uint32_t                             pic_width_in_luma_samples;
-    uint32_t                             pic_height_in_luma_samples;
-    uint8_t                              sps_video_parameter_set_id;
-    uint8_t                              sps_max_sub_layers_minus1;
-    uint8_t                              sps_seq_parameter_set_id;
-    uint8_t                              chroma_format_idc;
-    uint8_t                              bit_depth_luma_minus8;
-    uint8_t                              bit_depth_chroma_minus8;
-    uint8_t                              log2_max_pic_order_cnt_lsb_minus4;
-    uint8_t                              sps_max_dec_pic_buffering_minus1;
-    uint8_t                              log2_min_luma_coding_block_size_minus3;
-    uint8_t                              log2_diff_max_min_luma_coding_block_size;
-    uint8_t                              log2_min_luma_transform_block_size_minus2;
-    uint8_t                              log2_diff_max_min_luma_transform_block_size;
-    uint8_t                              max_transform_hierarchy_depth_inter;
-    uint8_t                              max_transform_hierarchy_depth_intra;
-    uint8_t                              num_short_term_ref_pic_sets;
-    uint8_t                              num_long_term_ref_pics_sps;
-    uint8_t                              pcm_sample_bit_depth_luma_minus1;
-    uint8_t                              pcm_sample_bit_depth_chroma_minus1;
-    uint8_t                              log2_min_pcm_luma_coding_block_size_minus3;
-    uint8_t                              log2_diff_max_min_pcm_luma_coding_block_size;
-    uint32_t                             conf_win_left_offset;
-    uint32_t                             conf_win_right_offset;
-    uint32_t                             conf_win_top_offset;
-    uint32_t                             conf_win_bottom_offset;
-    StdVideoH265DecPicBufMgr*            pDecPicBufMgr;
-    StdVideoH265SpsFlags                 flags;
-    StdVideoH265ScalingLists*            pScalingLists;             // Must be a valid pointer if sps_scaling_list_data_present_flag is set
-    StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui;  // Must be a valid pointer if StdVideoH265SpsFlags:vui_parameters_present_flag is set palette_max_size;
-
-    // extension SPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set
-    uint8_t                              palette_max_size;
-    uint8_t                              delta_palette_max_predictor_size;
-    uint8_t                              motion_vector_resolution_control_idc;
-    uint8_t                              sps_num_palette_predictor_initializer_minus1;
-    StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries;  // Must be a valid pointer if sps_palette_predictor_initializer_present_flag is set
+typedef struct StdVideoH265SequenceParameterSet {
+    StdVideoH265ProfileIdc                  profile_idc;
+    StdVideoH265Level                       level_idc;
+    uint32_t                                pic_width_in_luma_samples;
+    uint32_t                                pic_height_in_luma_samples;
+    uint8_t                                 sps_video_parameter_set_id;
+    uint8_t                                 sps_max_sub_layers_minus1;
+    uint8_t                                 sps_seq_parameter_set_id;
+    uint8_t                                 chroma_format_idc;
+    uint8_t                                 bit_depth_luma_minus8;
+    uint8_t                                 bit_depth_chroma_minus8;
+    uint8_t                                 log2_max_pic_order_cnt_lsb_minus4;
+    uint8_t                                 sps_max_dec_pic_buffering_minus1;
+    uint8_t                                 log2_min_luma_coding_block_size_minus3;
+    uint8_t                                 log2_diff_max_min_luma_coding_block_size;
+    uint8_t                                 log2_min_luma_transform_block_size_minus2;
+    uint8_t                                 log2_diff_max_min_luma_transform_block_size;
+    uint8_t                                 max_transform_hierarchy_depth_inter;
+    uint8_t                                 max_transform_hierarchy_depth_intra;
+    uint8_t                                 num_short_term_ref_pic_sets;
+    uint8_t                                 num_long_term_ref_pics_sps;
+    uint8_t                                 pcm_sample_bit_depth_luma_minus1;
+    uint8_t                                 pcm_sample_bit_depth_chroma_minus1;
+    uint8_t                                 log2_min_pcm_luma_coding_block_size_minus3;
+    uint8_t                                 log2_diff_max_min_pcm_luma_coding_block_size;
+    uint32_t                                conf_win_left_offset;
+    uint32_t                                conf_win_right_offset;
+    uint32_t                                conf_win_top_offset;
+    uint32_t                                conf_win_bottom_offset;
+    StdVideoH265DecPicBufMgr*               pDecPicBufMgr;
+    StdVideoH265SpsFlags                    flags;
+    StdVideoH265ScalingLists*               pScalingLists;
+    StdVideoH265SequenceParameterSetVui*    pSequenceParameterSetVui;
+    uint8_t                                 palette_max_size;
+    uint8_t                                 delta_palette_max_predictor_size;
+    uint8_t                                 motion_vector_resolution_control_idc;
+    uint8_t                                 sps_num_palette_predictor_initializer_minus1;
+    StdVideoH265PredictorPaletteEntries*    pPredictorPaletteEntries;
 } StdVideoH265SequenceParameterSet;
 
-
 typedef struct StdVideoH265PpsFlags {
-    uint32_t dependent_slice_segments_enabled_flag : 1;
-    uint32_t output_flag_present_flag : 1;
-    uint32_t sign_data_hiding_enabled_flag : 1;
-    uint32_t cabac_init_present_flag : 1;
-    uint32_t constrained_intra_pred_flag : 1;
-    uint32_t transform_skip_enabled_flag : 1;
-    uint32_t cu_qp_delta_enabled_flag : 1;
-    uint32_t pps_slice_chroma_qp_offsets_present_flag : 1;
-    uint32_t weighted_pred_flag : 1;
-    uint32_t weighted_bipred_flag : 1;
-    uint32_t transquant_bypass_enabled_flag : 1;
-    uint32_t tiles_enabled_flag : 1;
-    uint32_t entropy_coding_sync_enabled_flag : 1;
-    uint32_t uniform_spacing_flag : 1;
-    uint32_t loop_filter_across_tiles_enabled_flag : 1;
-    uint32_t pps_loop_filter_across_slices_enabled_flag : 1;
-    uint32_t deblocking_filter_control_present_flag : 1;
-    uint32_t deblocking_filter_override_enabled_flag : 1;
-    uint32_t pps_deblocking_filter_disabled_flag : 1;
-    uint32_t pps_scaling_list_data_present_flag : 1;
-    uint32_t lists_modification_present_flag : 1;
-    uint32_t slice_segment_header_extension_present_flag : 1;
-    uint32_t pps_extension_present_flag : 1;
-
-    // extension PPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS is set
-    uint32_t cross_component_prediction_enabled_flag : 1;
-    uint32_t chroma_qp_offset_list_enabled_flag : 1;
-
-    // extension PPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set
-    uint32_t pps_curr_pic_ref_enabled_flag : 1;
-    uint32_t residual_adaptive_colour_transform_enabled_flag : 1;
-    uint32_t pps_slice_act_qp_offsets_present_flag : 1;
-    uint32_t pps_palette_predictor_initializer_present_flag : 1;
-    uint32_t monochrome_palette_flag : 1;
-    uint32_t pps_range_extension_flag : 1;
+    uint32_t    dependent_slice_segments_enabled_flag : 1;
+    uint32_t    output_flag_present_flag : 1;
+    uint32_t    sign_data_hiding_enabled_flag : 1;
+    uint32_t    cabac_init_present_flag : 1;
+    uint32_t    constrained_intra_pred_flag : 1;
+    uint32_t    transform_skip_enabled_flag : 1;
+    uint32_t    cu_qp_delta_enabled_flag : 1;
+    uint32_t    pps_slice_chroma_qp_offsets_present_flag : 1;
+    uint32_t    weighted_pred_flag : 1;
+    uint32_t    weighted_bipred_flag : 1;
+    uint32_t    transquant_bypass_enabled_flag : 1;
+    uint32_t    tiles_enabled_flag : 1;
+    uint32_t    entropy_coding_sync_enabled_flag : 1;
+    uint32_t    uniform_spacing_flag : 1;
+    uint32_t    loop_filter_across_tiles_enabled_flag : 1;
+    uint32_t    pps_loop_filter_across_slices_enabled_flag : 1;
+    uint32_t    deblocking_filter_control_present_flag : 1;
+    uint32_t    deblocking_filter_override_enabled_flag : 1;
+    uint32_t    pps_deblocking_filter_disabled_flag : 1;
+    uint32_t    pps_scaling_list_data_present_flag : 1;
+    uint32_t    lists_modification_present_flag : 1;
+    uint32_t    slice_segment_header_extension_present_flag : 1;
+    uint32_t    pps_extension_present_flag : 1;
+    uint32_t    cross_component_prediction_enabled_flag : 1;
+    uint32_t    chroma_qp_offset_list_enabled_flag : 1;
+    uint32_t    pps_curr_pic_ref_enabled_flag : 1;
+    uint32_t    residual_adaptive_colour_transform_enabled_flag : 1;
+    uint32_t    pps_slice_act_qp_offsets_present_flag : 1;
+    uint32_t    pps_palette_predictor_initializer_present_flag : 1;
+    uint32_t    monochrome_palette_flag : 1;
+    uint32_t    pps_range_extension_flag : 1;
 } StdVideoH265PpsFlags;
 
-typedef struct StdVideoH265PictureParameterSet
-{
-    uint8_t                              pps_pic_parameter_set_id;
-    uint8_t                              pps_seq_parameter_set_id;
-    uint8_t                              num_extra_slice_header_bits;
-    uint8_t                              num_ref_idx_l0_default_active_minus1;
-    uint8_t                              num_ref_idx_l1_default_active_minus1;
-    int8_t                               init_qp_minus26;
-    uint8_t                              diff_cu_qp_delta_depth;
-    int8_t                               pps_cb_qp_offset;
-    int8_t                               pps_cr_qp_offset;
-    uint8_t                              num_tile_columns_minus1;
-    uint8_t                              num_tile_rows_minus1;
-    uint16_t                             column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE];
-    uint16_t                             row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE];
-    int8_t                               pps_beta_offset_div2;
-    int8_t                               pps_tc_offset_div2;
-    uint8_t                              log2_parallel_merge_level_minus2;
-    StdVideoH265PpsFlags                 flags;
-    StdVideoH265ScalingLists*            pScalingLists; // Must be a valid pointer if pps_scaling_list_data_present_flag is set
-
-    // extension PPS, valid when STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS is set
-    uint8_t                              log2_max_transform_skip_block_size_minus2;
-    uint8_t                              diff_cu_chroma_qp_offset_depth;
-    uint8_t                              chroma_qp_offset_list_len_minus1;
-    int8_t                               cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
-    int8_t                               cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
-    uint8_t                              log2_sao_offset_scale_luma;
-    uint8_t                              log2_sao_offset_scale_chroma;
-
-    // extension PPS, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set
-    int8_t                               pps_act_y_qp_offset_plus5;
-    int8_t                               pps_act_cb_qp_offset_plus5;
-    int8_t                               pps_act_cr_qp_offset_plus5;
-    uint8_t                              pps_num_palette_predictor_initializer;
-    uint8_t                              luma_bit_depth_entry_minus8;
-    uint8_t                              chroma_bit_depth_entry_minus8;
-    StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries;  // Must be a valid pointer if pps_palette_predictor_initializer_present_flag is set
+typedef struct StdVideoH265PictureParameterSet {
+    uint8_t                                 pps_pic_parameter_set_id;
+    uint8_t                                 pps_seq_parameter_set_id;
+    uint8_t                                 num_extra_slice_header_bits;
+    uint8_t                                 num_ref_idx_l0_default_active_minus1;
+    uint8_t                                 num_ref_idx_l1_default_active_minus1;
+    int8_t                                  init_qp_minus26;
+    uint8_t                                 diff_cu_qp_delta_depth;
+    int8_t                                  pps_cb_qp_offset;
+    int8_t                                  pps_cr_qp_offset;
+    uint8_t                                 num_tile_columns_minus1;
+    uint8_t                                 num_tile_rows_minus1;
+    uint16_t                                column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE];
+    uint16_t                                row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE];
+    int8_t                                  pps_beta_offset_div2;
+    int8_t                                  pps_tc_offset_div2;
+    uint8_t                                 log2_parallel_merge_level_minus2;
+    StdVideoH265PpsFlags                    flags;
+    StdVideoH265ScalingLists*               pScalingLists;
+    uint8_t                                 log2_max_transform_skip_block_size_minus2;
+    uint8_t                                 diff_cu_chroma_qp_offset_depth;
+    uint8_t                                 chroma_qp_offset_list_len_minus1;
+    int8_t                                  cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
+    int8_t                                  cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
+    uint8_t                                 log2_sao_offset_scale_luma;
+    uint8_t                                 log2_sao_offset_scale_chroma;
+    int8_t                                  pps_act_y_qp_offset_plus5;
+    int8_t                                  pps_act_cb_qp_offset_plus5;
+    int8_t                                  pps_act_cr_qp_offset_plus5;
+    uint8_t                                 pps_num_palette_predictor_initializer;
+    uint8_t                                 luma_bit_depth_entry_minus8;
+    uint8_t                                 chroma_bit_depth_entry_minus8;
+    StdVideoH265PredictorPaletteEntries*    pPredictorPaletteEntries;
 } StdVideoH265PictureParameterSet;
 
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif // VULKAN_VIDEO_CODEC_H265STD_H_
+#endif
diff --git a/include/vk_video/vulkan_video_codec_h265std_decode.h b/include/vk_video/vulkan_video_codec_h265std_decode.h
index a1efa05..ff06b11 100644
--- a/include/vk_video/vulkan_video_codec_h265std_decode.h
+++ b/include/vk_video/vulkan_video_codec_h265std_decode.h
@@ -1,64 +1,60 @@
+#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_
+#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
+
 /*
-** Copyright (c) 2019-2021 The Khronos Group Inc.
+** Copyright 2015-2021 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
 
-#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_
-#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "vk_video/vulkan_video_codec_h265std.h"
 
-// *************************************************
-// Video h265 Decode related parameters:
-// *************************************************
 
+#define vulkan_video_codec_h265std_decode 1
 #define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8
-
 typedef struct StdVideoDecodeH265PictureInfoFlags {
-    uint32_t IrapPicFlag : 1;
-    uint32_t IdrPicFlag  : 1;
-    uint32_t IsReference : 1;
-    uint32_t short_term_ref_pic_set_sps_flag : 1;
+    uint32_t    IrapPicFlag : 1;
+    uint32_t    IdrPicFlag  : 1;
+    uint32_t    IsReference : 1;
+    uint32_t    short_term_ref_pic_set_sps_flag : 1;
 } StdVideoDecodeH265PictureInfoFlags;
 
 typedef struct StdVideoDecodeH265PictureInfo {
-    uint8_t                            vps_video_parameter_set_id;
-    uint8_t                            sps_seq_parameter_set_id;
-    uint8_t                            pps_pic_parameter_set_id;
-    uint8_t                            num_short_term_ref_pic_sets;
-    int32_t                            PicOrderCntVal;
-    uint16_t                           NumBitsForSTRefPicSetInSlice; // number of bits used in st_ref_pic_set()
-                                                                     //when short_term_ref_pic_set_sps_flag is 0; otherwise set to 0.
-    uint8_t                            NumDeltaPocsOfRefRpsIdx;      // NumDeltaPocs[ RefRpsIdx ] when short_term_ref_pic_set_sps_flag = 1, otherwise 0
-    uint8_t                            RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; // slotIndex as used in
-                                                                     // VkVideoReferenceSlotKHR structures representing
-                                                                     //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex
-    uint8_t                            RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE];   // slotIndex as used in
-                                                                     // VkVideoReferenceSlotKHR structures representing
-                                                                     //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex
-    uint8_t                            RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; // slotIndex as used in
-                                                                     // VkVideoReferenceSlotKHR structures representing
-                                                                     //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex
-    StdVideoDecodeH265PictureInfoFlags flags;
+    uint8_t                               vps_video_parameter_set_id;
+    uint8_t                               sps_seq_parameter_set_id;
+    uint8_t                               pps_pic_parameter_set_id;
+    uint8_t                               num_short_term_ref_pic_sets;
+    int32_t                               PicOrderCntVal;
+    uint16_t                              NumBitsForSTRefPicSetInSlice;
+    uint8_t                               NumDeltaPocsOfRefRpsIdx;
+    uint8_t                               RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE];
+    uint8_t                               RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE];
+    uint8_t                               RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE];
+    StdVideoDecodeH265PictureInfoFlags    flags;
 } StdVideoDecodeH265PictureInfo;
 
 typedef struct StdVideoDecodeH265ReferenceInfoFlags {
-    uint32_t is_long_term : 1;
-    uint32_t is_non_existing : 1;
+    uint32_t    is_long_term : 1;
+    uint32_t    is_non_existing : 1;
 } StdVideoDecodeH265ReferenceInfoFlags;
 
 typedef struct StdVideoDecodeH265ReferenceInfo {
-    int32_t                              PicOrderCntVal;
-    StdVideoDecodeH265ReferenceInfoFlags flags;
+    int32_t                                 PicOrderCntVal;
+    StdVideoDecodeH265ReferenceInfoFlags    flags;
 } StdVideoDecodeH265ReferenceInfo;
 
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif // VULKAN_VIDEO_CODEC_H265STD_DECODE_H_
+#endif
diff --git a/include/vk_video/vulkan_video_codec_h265std_encode.h b/include/vk_video/vulkan_video_codec_h265std_encode.h
index ffffef2..d867751 100644
--- a/include/vk_video/vulkan_video_codec_h265std_encode.h
+++ b/include/vk_video/vulkan_video_codec_h265std_encode.h
@@ -1,122 +1,125 @@
+#ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_
+#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
+
 /*
-** Copyright (c) 2019-2021 The Khronos Group Inc.
+** Copyright 2015-2021 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
 
-#ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_
-#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "vk_video/vulkan_video_codec_h265std.h"
 
-// *************************************************
-// Video h265 Encode related parameters:
-// *************************************************
 
-#define STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE   15
+#define vulkan_video_codec_h265std_encode 1
+#define STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE 15
 #define STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE 15
-#define STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM  2
-
+#define STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM 2
 typedef struct StdVideoEncodeH265SliceHeaderFlags {
-    uint32_t first_slice_segment_in_pic_flag : 1;
-    uint32_t no_output_of_prior_pics_flag : 1;
-    uint32_t dependent_slice_segment_flag : 1;
-    uint32_t short_term_ref_pic_set_sps_flag : 1;
-    uint32_t slice_temporal_mvp_enable_flag : 1;
-    uint32_t slice_sao_luma_flag : 1;
-    uint32_t slice_sao_chroma_flag : 1;
-    uint32_t num_ref_idx_active_override_flag : 1;
-    uint32_t mvd_l1_zero_flag : 1;
-    uint32_t cabac_init_flag : 1;
-    uint32_t slice_deblocking_filter_disable_flag : 1;
-    uint32_t collocated_from_l0_flag : 1;
-    uint32_t slice_loop_filter_across_slices_enabled_flag : 1;
-    uint32_t bLastSliceInPic : 1;
-    uint32_t reservedBits : 18;
-    uint16_t luma_weight_l0_flag;   // bit 0 - num_ref_idx_l0_active_minus1
-    uint16_t chroma_weight_l0_flag; // bit 0 - num_ref_idx_l0_active_minus1
-    uint16_t luma_weight_l1_flag;   // bit 0 - num_ref_idx_l1_active_minus1
-    uint16_t chroma_weight_l1_flag; // bit 0 - num_ref_idx_l1_active_minus1
+    uint32_t    first_slice_segment_in_pic_flag : 1;
+    uint32_t    no_output_of_prior_pics_flag : 1;
+    uint32_t    dependent_slice_segment_flag : 1;
+    uint32_t    short_term_ref_pic_set_sps_flag : 1;
+    uint32_t    slice_temporal_mvp_enable_flag : 1;
+    uint32_t    slice_sao_luma_flag : 1;
+    uint32_t    slice_sao_chroma_flag : 1;
+    uint32_t    num_ref_idx_active_override_flag : 1;
+    uint32_t    mvd_l1_zero_flag : 1;
+    uint32_t    cabac_init_flag : 1;
+    uint32_t    slice_deblocking_filter_disable_flag : 1;
+    uint32_t    collocated_from_l0_flag : 1;
+    uint32_t    slice_loop_filter_across_slices_enabled_flag : 1;
+    uint32_t    bLastSliceInPic : 1;
+    uint32_t    reservedBits : 18;
+    uint16_t    luma_weight_l0_flag;
+    uint16_t    chroma_weight_l0_flag;
+    uint16_t    luma_weight_l1_flag;
+    uint16_t    chroma_weight_l1_flag;
 } StdVideoEncodeH265SliceHeaderFlags;
 
 typedef struct StdVideoEncodeH265SliceHeader {
-    StdVideoH265SliceType              slice_type;
-    uint8_t                            slice_pic_parameter_set_id;
-    uint8_t                            num_short_term_ref_pic_sets;
-    uint32_t                           slice_segment_address;
-    uint8_t                            short_term_ref_pic_set_idx;
-    uint8_t                            num_long_term_sps;
-    uint8_t                            num_long_term_pics;
-    uint8_t                            collocated_ref_idx;
-    uint8_t                            num_ref_idx_l0_active_minus1; // [0, 14]
-    uint8_t                            num_ref_idx_l1_active_minus1; // [0, 14]
-    uint8_t                            luma_log2_weight_denom;       // [0, 7]
-    int8_t                             delta_chroma_log2_weight_denom;
-    int8_t                             delta_luma_weight_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
-    int8_t                             luma_offset_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
-    int8_t                             delta_chroma_weight_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
-    int8_t                             delta_chroma_offset_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
-    int8_t                             delta_luma_weight_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
-    int8_t                             luma_offset_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
-    int8_t                             delta_chroma_weight_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
-    int8_t                             delta_chroma_offset_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
-    uint8_t                            MaxNumMergeCand;
-    int8_t                             slice_qp_delta;
-    int8_t                             slice_cb_qp_offset;         // [-12, 12]
-    int8_t                             slice_cr_qp_offset;         // [-12, 12]
-    int8_t                             slice_beta_offset_div2;    // [-6, 6]
-    int8_t                             slice_tc_offset_div2;       // [-6, 6]
-    int8_t                             slice_act_y_qp_offset;
-    int8_t                             slice_act_cb_qp_offset;
-    int8_t                             slice_act_cr_qp_offset;
-    StdVideoEncodeH265SliceHeaderFlags flags;
+    StdVideoH265SliceType                 slice_type;
+    uint8_t                               slice_pic_parameter_set_id;
+    uint8_t                               num_short_term_ref_pic_sets;
+    uint32_t                              slice_segment_address;
+    uint8_t                               short_term_ref_pic_set_idx;
+    uint8_t                               num_long_term_sps;
+    uint8_t                               num_long_term_pics;
+    uint8_t                               collocated_ref_idx;
+    uint8_t                               num_ref_idx_l0_active_minus1;
+    uint8_t                               num_ref_idx_l1_active_minus1;
+    uint8_t                               luma_log2_weight_denom;
+    int8_t                                delta_chroma_log2_weight_denom;
+    int8_t                                delta_luma_weight_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
+    int8_t                                luma_offset_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
+    int8_t                                delta_chroma_weight_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
+    int8_t                                delta_chroma_offset_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
+    int8_t                                delta_luma_weight_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
+    int8_t                                luma_offset_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE];
+    int8_t                                delta_chroma_weight_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
+    int8_t                                delta_chroma_offset_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM];
+    uint8_t                               MaxNumMergeCand;
+    int8_t                                slice_qp_delta;
+    int8_t                                slice_cb_qp_offset;
+    int8_t                                slice_cr_qp_offset;
+    int8_t                                slice_beta_offset_div2;
+    int8_t                                slice_tc_offset_div2;
+    int8_t                                slice_act_y_qp_offset;
+    int8_t                                slice_act_cb_qp_offset;
+    int8_t                                slice_act_cr_qp_offset;
+    StdVideoEncodeH265SliceHeaderFlags    flags;
 } StdVideoEncodeH265SliceHeader;
 
 typedef struct StdVideoEncodeH265ReferenceModificationFlags {
-    uint32_t ref_pic_list_modification_flag_l0 : 1;
-    uint32_t ref_pic_list_modification_flag_l1 : 1;
+    uint32_t    ref_pic_list_modification_flag_l0 : 1;
+    uint32_t    ref_pic_list_modification_flag_l1 : 1;
 } StdVideoEncodeH265ReferenceModificationFlags;
 
 typedef struct StdVideoEncodeH265ReferenceModifications {
-    StdVideoEncodeH265ReferenceModificationFlags flags;
-    uint8_t                                      referenceList0ModificationsCount; // num_ref_idx_l0_active_minus1
-    uint8_t*                                     pReferenceList0Modifications;     // list_entry_l0
-    uint8_t                                      referenceList1ModificationsCount; // num_ref_idx_l1_active_minus1
-    uint8_t*                                     pReferenceList1Modifications;     // list_entry_l1
+    StdVideoEncodeH265ReferenceModificationFlags    flags;
+    uint8_t                                         referenceList0ModificationsCount;
+    uint8_t*                                        pReferenceList0Modifications;
+    uint8_t                                         referenceList1ModificationsCount;
+    uint8_t*                                        pReferenceList1Modifications;
 } StdVideoEncodeH265ReferenceModifications;
 
 typedef struct StdVideoEncodeH265PictureInfoFlags {
-    uint32_t is_reference_flag : 1;
-    uint32_t IrapPicFlag : 1;
-    uint32_t long_term_flag : 1;
+    uint32_t    is_reference_flag : 1;
+    uint32_t    IrapPicFlag : 1;
+    uint32_t    long_term_flag : 1;
 } StdVideoEncodeH265PictureInfoFlags;
 
 typedef struct StdVideoEncodeH265PictureInfo {
-    StdVideoH265PictureType            PictureType;
-    uint8_t                            sps_video_parameter_set_id;
-    uint8_t                            pps_seq_parameter_set_id;
-    int32_t                            PicOrderCntVal;
-    uint8_t                            TemporalId;
-    StdVideoEncodeH265PictureInfoFlags flags;
+    StdVideoH265PictureType               PictureType;
+    uint8_t                               sps_video_parameter_set_id;
+    uint8_t                               pps_seq_parameter_set_id;
+    int32_t                               PicOrderCntVal;
+    uint8_t                               TemporalId;
+    StdVideoEncodeH265PictureInfoFlags    flags;
 } StdVideoEncodeH265PictureInfo;
 
 typedef struct StdVideoEncodeH265ReferenceInfoFlags {
-    uint32_t is_long_term : 1;
-    uint32_t isUsedFlag : 1;
+    uint32_t    is_long_term : 1;
+    uint32_t    isUsedFlag : 1;
 } StdVideoEncodeH265ReferenceInfoFlags;
 
 typedef struct StdVideoEncodeH265ReferenceInfo {
-    int32_t                              PicOrderCntVal;
-    uint8_t                              TemporalId;
-    StdVideoEncodeH265ReferenceInfoFlags flags;
+    int32_t                                 PicOrderCntVal;
+    uint8_t                                 TemporalId;
+    StdVideoEncodeH265ReferenceInfoFlags    flags;
 } StdVideoEncodeH265ReferenceInfo;
 
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif // VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_
+#endif
diff --git a/include/vk_video/vulkan_video_codecs_common.h b/include/vk_video/vulkan_video_codecs_common.h
index 8cc227a..b7efd16 100644
--- a/include/vk_video/vulkan_video_codecs_common.h
+++ b/include/vk_video/vulkan_video_codecs_common.h
@@ -1,21 +1,31 @@
+#ifndef VULKAN_VIDEO_CODECS_COMMON_H_
+#define VULKAN_VIDEO_CODECS_COMMON_H_ 1
+
 /*
-** Copyright (c) 2019-2021 The Khronos Group Inc.
+** Copyright 2015-2021 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
 
-#ifndef VULKAN_VIDEO_CODEC_COMMON_H_
-#define VULKAN_VIDEO_CODEC_COMMON_H_ 1
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+
+
+#define vulkan_video_codecs_common 1
 #define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \
     ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
 
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif // VULKAN_VIDEO_CODEC_COMMON_H_
+#endif
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 0445ff1..dbb9e89 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -119,7 +119,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 202, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 203, "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
@@ -234,11 +234,6 @@ static_assert( VK_HEADER_VERSION == 202, "Wrong VK_HEADER_VERSION!" );
 #  define VULKAN_HPP_NAMESPACE vk
 #endif
 
-#if !defined( VULKAN_HPP_HASH_COMBINE )
-#  define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \
-    seed ^= std::hash<std::remove_const<valueType>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 )
-#endif
-
 #define VULKAN_HPP_STRINGIFY2( text ) #text
 #define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
 #define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
@@ -818,20 +813,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     return flags.operator^( bit );
   }
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <typename BitType>
-struct std::hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT
-  {
-    return std::hash<typename std::underlying_type<BitType>::type>{}(
-      static_cast<typename std::underlying_type<BitType>::type>( flags ) );
-  }
-};
 
-namespace VULKAN_HPP_NAMESPACE
-{
   template <typename RefType>
   class Optional
   {
@@ -7446,6 +7428,14 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_KHR_video_queue ===
   template <>
+  struct StructExtends<QueueFamilyQueryResultStatusProperties2KHR, QueueFamilyProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<VideoQueueFamilyProperties2KHR, QueueFamilyProperties2>
   {
     enum
@@ -11030,6 +11020,58 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_QCOM_fragment_density_map_offset ===
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  //=== VK_NV_linear_color_attachment ===
+  template <>
+  struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
   class DynamicLoader
   {
diff --git a/include/vulkan/vulkan_beta.h b/include/vulkan/vulkan_beta.h
index 3b1a55a..26dbdb8 100644
--- a/include/vulkan/vulkan_beta.h
+++ b/include/vulkan/vulkan_beta.h
@@ -99,6 +99,12 @@ typedef enum VkVideoCodingQualityPresetFlagBitsKHR {
     VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoCodingQualityPresetFlagBitsKHR;
 typedef VkFlags VkVideoCodingQualityPresetFlagsKHR;
+typedef struct VkQueueFamilyQueryResultStatusProperties2KHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           supported;
+} VkQueueFamilyQueryResultStatusProperties2KHR;
+
 typedef struct VkVideoQueueFamilyProperties2KHR {
     VkStructureType                  sType;
     void*                            pNext;
@@ -444,7 +450,7 @@ 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 2
+#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 3
 #define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
 
 typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
@@ -459,7 +465,6 @@ typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
     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_CAPABILITY_OPTIONAL_RC_EXTENSION_STRUCT_BIT_EXT = 0x00000800,
     VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkVideoEncodeH264CapabilityFlagBitsEXT;
 typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
@@ -587,6 +592,7 @@ typedef struct VkVideoEncodeH264RateControlInfoEXT {
     uint32_t                                            idrPeriod;
     uint32_t                                            consecutiveBFrameCount;
     VkVideoEncodeH264RateControlStructureFlagBitsEXT    rateControlStructure;
+    uint8_t                                             temporalLayerCount;
 } VkVideoEncodeH264RateControlInfoEXT;
 
 typedef struct VkVideoEncodeH264QpEXT {
@@ -620,7 +626,7 @@ typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
 #define VK_EXT_video_encode_h265 1
 #include "vk_video/vulkan_video_codec_h265std.h"
 #include "vk_video/vulkan_video_codec_h265std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 2
+#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 3
 #define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
 typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT;
 
@@ -758,6 +764,7 @@ typedef struct VkVideoEncodeH265RateControlInfoEXT {
     uint32_t                                            idrPeriod;
     uint32_t                                            consecutiveBFrameCount;
     VkVideoEncodeH265RateControlStructureFlagBitsEXT    rateControlStructure;
+    uint8_t                                             subLayerCount;
 } VkVideoEncodeH265RateControlInfoEXT;
 
 typedef struct VkVideoEncodeH265QpEXT {
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index f6e07ce..8bc98d5 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 202
+#define VK_HEADER_VERSION 203
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
@@ -419,6 +419,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015,
 #endif
 #ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR = 1000023016,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000,
 #endif
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
@@ -926,6 +929,10 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = 1000413001,
     VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = 1000413002,
     VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = 1000413003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001,
+    VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -1962,6 +1969,7 @@ typedef enum VkImageCreateFlagBits {
     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
     VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
+    VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000,
     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
@@ -8669,6 +8677,7 @@ static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL;
 #endif
+static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL;
 
 typedef struct VkFormatProperties3KHR {
     VkStructureType             sType;
@@ -13179,6 +13188,46 @@ VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(
 #endif
 
 
+#define VK_QCOM_fragment_density_map_offset 1
+#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1
+#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"
+typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fragmentDensityMapOffset;
+} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+
+typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+    VkStructureType    sType;
+    void*              pNext;
+    VkExtent2D         fragmentDensityOffsetGranularity;
+} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+
+typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM {
+    VkStructureType      sType;
+    const void*          pNext;
+    uint32_t             fragmentDensityOffsetCount;
+    const VkOffset2D*    pFragmentDensityOffsets;
+} VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
+
+
+
+#define VK_NV_linear_color_attachment 1
+#define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1
+#define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment"
+typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           linearColorAttachment;
+} VkPhysicalDeviceLinearColorAttachmentFeaturesNV;
+
+
+
+#define VK_GOOGLE_surfaceless_query 1
+#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 1
+#define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query"
+
+
 #define VK_KHR_acceleration_structure 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp
index 3ce4796..858e437 100644
--- a/include/vulkan/vulkan_enums.hpp
+++ b/include/vulkan/vulkan_enums.hpp
@@ -336,23 +336,24 @@ namespace VULKAN_HPP_NAMESPACE
     eDebugMarkerObjectTagInfoEXT  = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
     eDebugMarkerMarkerInfoEXT     = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT,
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    eVideoProfileKHR                     = VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR,
-    eVideoCapabilitiesKHR                = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
-    eVideoPictureResourceKHR             = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR,
-    eVideoGetMemoryPropertiesKHR         = VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR,
-    eVideoBindMemoryKHR                  = VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR,
-    eVideoSessionCreateInfoKHR           = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
-    eVideoSessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
-    eVideoSessionParametersUpdateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR,
-    eVideoBeginCodingInfoKHR             = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
-    eVideoEndCodingInfoKHR               = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
-    eVideoCodingControlInfoKHR           = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
-    eVideoReferenceSlotKHR               = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR,
-    eVideoQueueFamilyProperties2KHR      = VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR,
-    eVideoProfilesKHR                    = VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR,
-    ePhysicalDeviceVideoFormatInfoKHR    = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
-    eVideoFormatPropertiesKHR            = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR,
-    eVideoDecodeInfoKHR                  = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
+    eVideoProfileKHR                            = VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR,
+    eVideoCapabilitiesKHR                       = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
+    eVideoPictureResourceKHR                    = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR,
+    eVideoGetMemoryPropertiesKHR                = VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR,
+    eVideoBindMemoryKHR                         = VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR,
+    eVideoSessionCreateInfoKHR                  = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
+    eVideoSessionParametersCreateInfoKHR        = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
+    eVideoSessionParametersUpdateInfoKHR        = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR,
+    eVideoBeginCodingInfoKHR                    = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
+    eVideoEndCodingInfoKHR                      = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
+    eVideoCodingControlInfoKHR                  = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
+    eVideoReferenceSlotKHR                      = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR,
+    eVideoQueueFamilyProperties2KHR             = VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR,
+    eVideoProfilesKHR                           = VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR,
+    ePhysicalDeviceVideoFormatInfoKHR           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
+    eVideoFormatPropertiesKHR                   = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR,
+    eQueueFamilyQueryResultStatusProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR,
+    eVideoDecodeInfoKHR                         = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
     eDedicatedAllocationImageCreateInfoNV         = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
     eDedicatedAllocationBufferCreateInfoNV        = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
@@ -901,6 +902,13 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceMaintenance4PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR,
     eDeviceBufferMemoryRequirementsKHR       = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR,
     eDeviceImageMemoryRequirementsKHR        = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR,
+    ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
+    ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
+    eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
+    ePhysicalDeviceLinearColorAttachmentFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV,
     eAttachmentDescription2KHR               = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
     eAttachmentDescriptionStencilLayoutKHR   = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
     eAttachmentReference2KHR                 = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
@@ -1266,6 +1274,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eVideoProfilesKHR: return "VideoProfilesKHR";
       case StructureType::ePhysicalDeviceVideoFormatInfoKHR: return "PhysicalDeviceVideoFormatInfoKHR";
       case StructureType::eVideoFormatPropertiesKHR: return "VideoFormatPropertiesKHR";
+      case StructureType::eQueueFamilyQueryResultStatusProperties2KHR:
+        return "QueueFamilyQueryResultStatusProperties2KHR";
       case StructureType::eVideoDecodeInfoKHR: return "VideoDecodeInfoKHR";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
       case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
@@ -1874,6 +1884,14 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceMaintenance4PropertiesKHR: return "PhysicalDeviceMaintenance4PropertiesKHR";
       case StructureType::eDeviceBufferMemoryRequirementsKHR: return "DeviceBufferMemoryRequirementsKHR";
       case StructureType::eDeviceImageMemoryRequirementsKHR: return "DeviceImageMemoryRequirementsKHR";
+      case StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM:
+        return "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM";
+      case StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM:
+        return "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM";
+      case StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM:
+        return "SubpassFragmentDensityMapOffsetEndInfoQCOM";
+      case StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV:
+        return "PhysicalDeviceLinearColorAttachmentFeaturesNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -2691,6 +2709,7 @@ namespace VULKAN_HPP_NAMESPACE
     eCornerSampledNV                   = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
     eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
     eSubsampledEXT                     = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT,
+    eFragmentDensityMapOffsetQCOM      = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM,
     e2DArrayCompatibleKHR              = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR,
     eAliasKHR                          = VK_IMAGE_CREATE_ALIAS_BIT_KHR,
     eBlockTexelViewCompatibleKHR       = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR,
@@ -2718,6 +2737,7 @@ namespace VULKAN_HPP_NAMESPACE
       case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV";
       case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT";
       case ImageCreateFlagBits::eSubsampledEXT: return "SubsampledEXT";
+      case ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM: return "FragmentDensityMapOffsetQCOM";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -6006,8 +6026,7 @@ namespace VULKAN_HPP_NAMESPACE
     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,
-    eOptionalRcExtensionStruct  = VK_VIDEO_ENCODE_H264_CAPABILITY_OPTIONAL_RC_EXTENSION_STRUCT_BIT_EXT
+    eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagBitsEXT value )
@@ -6025,7 +6044,6 @@ namespace VULKAN_HPP_NAMESPACE
       case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial";
       case VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame: return "MultipleSlicePerFrame";
       case VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize: return "EvenlyDistributedSliceSize";
-      case VideoEncodeH264CapabilityFlagBitsEXT::eOptionalRcExtensionStruct: return "OptionalRcExtensionStruct";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8230,8 +8248,9 @@ namespace VULKAN_HPP_NAMESPACE
     eFragmentShadingRateAttachment     = VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
     eVideoEncodeInput = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR,
-    eVideoEncodeDpb   = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR
+    eVideoEncodeDpb   = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR,
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    eLinearColorAttachmentNV = VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV
   };
 
   VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlagBits2KHR value )
@@ -8280,6 +8299,7 @@ namespace VULKAN_HPP_NAMESPACE
       case FormatFeatureFlagBits2KHR::eVideoEncodeInput: return "VideoEncodeInput";
       case FormatFeatureFlagBits2KHR::eVideoEncodeDpb: return "VideoEncodeDpb";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      case FormatFeatureFlagBits2KHR::eLinearColorAttachmentNV: return "LinearColorAttachmentNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8495,8 +8515,8 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8SrgbBlock: return 8;
       case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A1UnormBlock: return 8;
       case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A1SrgbBlock: return 8;
-      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock: return 8;
-      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8SrgbBlock: return 8;
+      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock: return 16;
+      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8SrgbBlock: return 16;
       case VULKAN_HPP_NAMESPACE::Format::eEacR11UnormBlock: return 8;
       case VULKAN_HPP_NAMESPACE::Format::eEacR11SnormBlock: return 8;
       case VULKAN_HPP_NAMESPACE::Format::eEacR11G11UnormBlock: return 16;
@@ -11820,16 +11840,16 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum : VkFlags
     {
-      allFlags = VkFlags( ImageCreateFlagBits::eSparseBinding ) | VkFlags( ImageCreateFlagBits::eSparseResidency ) |
-                 VkFlags( ImageCreateFlagBits::eSparseAliased ) | VkFlags( ImageCreateFlagBits::eMutableFormat ) |
-                 VkFlags( ImageCreateFlagBits::eCubeCompatible ) | VkFlags( ImageCreateFlagBits::eAlias ) |
-                 VkFlags( ImageCreateFlagBits::eSplitInstanceBindRegions ) |
-                 VkFlags( ImageCreateFlagBits::e2DArrayCompatible ) |
-                 VkFlags( ImageCreateFlagBits::eBlockTexelViewCompatible ) |
-                 VkFlags( ImageCreateFlagBits::eExtendedUsage ) | VkFlags( ImageCreateFlagBits::eProtected ) |
-                 VkFlags( ImageCreateFlagBits::eDisjoint ) | VkFlags( ImageCreateFlagBits::eCornerSampledNV ) |
-                 VkFlags( ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) |
-                 VkFlags( ImageCreateFlagBits::eSubsampledEXT )
+      allFlags =
+        VkFlags( ImageCreateFlagBits::eSparseBinding ) | VkFlags( ImageCreateFlagBits::eSparseResidency ) |
+        VkFlags( ImageCreateFlagBits::eSparseAliased ) | VkFlags( ImageCreateFlagBits::eMutableFormat ) |
+        VkFlags( ImageCreateFlagBits::eCubeCompatible ) | VkFlags( ImageCreateFlagBits::eAlias ) |
+        VkFlags( ImageCreateFlagBits::eSplitInstanceBindRegions ) | VkFlags( ImageCreateFlagBits::e2DArrayCompatible ) |
+        VkFlags( ImageCreateFlagBits::eBlockTexelViewCompatible ) | VkFlags( ImageCreateFlagBits::eExtendedUsage ) |
+        VkFlags( ImageCreateFlagBits::eProtected ) | VkFlags( ImageCreateFlagBits::eDisjoint ) |
+        VkFlags( ImageCreateFlagBits::eCornerSampledNV ) |
+        VkFlags( ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) |
+        VkFlags( ImageCreateFlagBits::eSubsampledEXT ) | VkFlags( ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM )
     };
   };
 
@@ -11892,6 +11912,8 @@ namespace VULKAN_HPP_NAMESPACE
       result += "SampleLocationsCompatibleDepthEXT | ";
     if ( value & ImageCreateFlagBits::eSubsampledEXT )
       result += "SubsampledEXT | ";
+    if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM )
+      result += "FragmentDensityMapOffsetQCOM | ";
 
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
@@ -16153,8 +16175,7 @@ namespace VULKAN_HPP_NAMESPACE
                  VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) |
                  VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) |
                  VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) |
-                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) |
-                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eOptionalRcExtensionStruct )
+                 VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
     };
   };
 
@@ -16210,8 +16231,6 @@ namespace VULKAN_HPP_NAMESPACE
       result += "MultipleSlicePerFrame | ";
     if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
       result += "EvenlyDistributedSliceSize | ";
-    if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eOptionalRcExtensionStruct )
-      result += "OptionalRcExtensionStruct | ";
 
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
@@ -18423,6 +18442,7 @@ namespace VULKAN_HPP_NAMESPACE
         | VkFlags64( FormatFeatureFlagBits2KHR::eVideoEncodeInput ) |
         VkFlags64( FormatFeatureFlagBits2KHR::eVideoEncodeDpb )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+        | VkFlags64( FormatFeatureFlagBits2KHR::eLinearColorAttachmentNV )
     };
   };
 
@@ -18528,6 +18548,8 @@ namespace VULKAN_HPP_NAMESPACE
     if ( value & FormatFeatureFlagBits2KHR::eVideoEncodeDpb )
       result += "VideoEncodeDpb | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    if ( value & FormatFeatureFlagBits2KHR::eLinearColorAttachmentNV )
+      result += "LinearColorAttachmentNV | ";
 
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp
index b3aa99c..741f759 100644
--- a/include/vulkan/vulkan_handles.hpp
+++ b/include/vulkan/vulkan_handles.hpp
@@ -427,6 +427,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_KHR_video_queue ===
+  struct QueueFamilyQueryResultStatusProperties2KHR;
   struct VideoQueueFamilyProperties2KHR;
   struct VideoProfileKHR;
   struct VideoProfilesKHR;
@@ -1312,6 +1313,14 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceBufferMemoryRequirementsKHR;
   struct DeviceImageMemoryRequirementsKHR;
 
+  //=== VK_QCOM_fragment_density_map_offset ===
+  struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+  struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+  struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
+
+  //=== VK_NV_linear_color_attachment ===
+  struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
+
   //===============
   //=== HANDLEs ===
   //===============
@@ -12596,8 +12605,8 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
-      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B                         = SurfaceFormatKHRAllocator,
@@ -12618,8 +12627,8 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
-      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B                       = PresentModeKHRAllocator,
@@ -14531,476 +14540,4 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 }  // namespace VULKAN_HPP_NAMESPACE
-
-namespace std
-{
-  //=======================
-  //=== HASH structures ===
-  //=======================
-
-  //=== VK_VERSION_1_0 ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Instance>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Device>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Queue>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Fence>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkFence>{}( static_cast<VkFence>( fence ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Event>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Buffer>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::BufferView>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Image>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::ImageView>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Sampler>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
-    }
-  };
-
-  //=== VK_VERSION_1_1 ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorUpdateTemplate>{}(
-        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
-    }
-  };
-
-  //=== VK_KHR_surface ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
-    }
-  };
-
-  //=== VK_KHR_swapchain ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
-    }
-  };
-
-  //=== VK_KHR_display ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
-    }
-  };
-
-  //=== VK_EXT_debug_report ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
-    }
-  };
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_KHR_video_queue ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkVideoSessionParametersKHR>{}(
-        static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) );
-    }
-  };
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_NVX_binary_import ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) );
-    }
-  };
-
-  //=== VK_EXT_debug_utils ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
-    }
-  };
-
-  //=== VK_KHR_acceleration_structure ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkAccelerationStructureKHR>{}(
-        static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
-    }
-  };
-
-  //=== VK_EXT_validation_cache ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
-    }
-  };
-
-  //=== VK_NV_ray_tracing ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkAccelerationStructureNV>{}(
-        static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) );
-    }
-  };
-
-  //=== VK_INTEL_performance_query ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL )
-      const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPerformanceConfigurationINTEL>{}(
-        static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
-    }
-  };
-
-  //=== VK_KHR_deferred_host_operations ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
-    }
-  };
-
-  //=== VK_NV_device_generated_commands ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkIndirectCommandsLayoutNV>{}(
-        static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
-    }
-  };
-
-  //=== VK_EXT_private_data ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) );
-    }
-  };
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_buffer_collection ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkBufferCollectionFUCHSIA>{}(
-        static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
-    }
-  };
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-}  // namespace std
 #endif
diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp
index f5827b9..5562fe9 100644
--- a/include/vulkan/vulkan_raii.hpp
+++ b/include/vulkan/vulkan_raii.hpp
@@ -2762,10 +2762,10 @@ namespace VULKAN_HPP_NAMESPACE
                            getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
-                           getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+        getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
-                           getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> getSurfacePresentModesKHR(
+        VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
       //=== VK_KHR_swapchain ===
 
diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp
index 48d6e24..bc87d15 100644
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
@@ -86,28 +86,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAabbPositionsKHR *>( this );
     }
 
-    operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAabbPositionsKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<float const &, float const &, float const &, float const &, float const &, float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( minX, minY, minZ, maxX, maxY, maxZ );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AabbPositionsKHR const & ) const = default;
 #else
     bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) &&
-             ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -127,26 +136,6 @@ namespace VULKAN_HPP_NAMESPACE
                             "AabbPositionsKHR is not nothrow_move_constructible!" );
   using AabbPositionsNV = AabbPositionsKHR;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minX );
-    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minY );
-    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minZ );
-    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxX );
-    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxY );
-    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxZ );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   union DeviceOrHostAddressConstKHR
   {
     using NativeType = VkDeviceOrHostAddressConstKHR;
@@ -189,8 +178,8 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress;
     const void *                        hostAddress;
 #else
-    VkDeviceAddress                                 deviceAddress;
-    const void *                                    hostAddress;
+    VkDeviceAddress deviceAddress;
+    const void *    hostAddress;
 #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
   };
 
@@ -298,16 +287,35 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR *>( this );
     }
 
-    operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::IndexType const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType        = StructureType::eAccelerationStructureGeometryTrianglesDataKHR;
     const void *                        pNext        = {};
@@ -394,16 +402,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR *>( this );
     }
 
-    operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, data, stride );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType               sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR;
     const void *                                      pNext = {};
@@ -485,16 +506,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR *>( this );
     }
 
-    operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, arrayOfPointers, data );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType           = StructureType::eAccelerationStructureGeometryInstancesDataKHR;
     const void *                        pNext           = {};
@@ -645,16 +679,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryKHR *>( this );
     }
 
-    operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureGeometryKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::GeometryTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR const &,
+               VULKAN_HPP_NAMESPACE::GeometryFlagsKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, geometryType, geometry, flags );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType   sType        = StructureType::eAccelerationStructureGeometryKHR;
     const void *                          pNext        = {};
@@ -718,8 +766,8 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress;
     void *                              hostAddress;
 #else
-    VkDeviceAddress                                 deviceAddress;
-    void *                                          hostAddress;
+    VkDeviceAddress deviceAddress;
+    void *          hostAddress;
 #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
   };
 
@@ -904,16 +952,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( this );
     }
 
-    operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::BuildAccelerationStructureModeKHR const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const &,
+               const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const * const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       type,
+                       flags,
+                       mode,
+                       srcAccelerationStructure,
+                       dstAccelerationStructure,
+                       geometryCount,
+                       pGeometries,
+                       ppGeometries,
+                       scratchData );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR;
     const void *                        pNext = {};
@@ -1009,28 +1087,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR *>( this );
     }
 
-    operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureBuildRangeInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) &&
-             ( firstVertex == rhs.firstVertex ) && ( transformOffset == rhs.transformOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -1050,25 +1137,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>::value,
     "AccelerationStructureBuildRangeInfoKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const &
-                            accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.firstVertex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.transformOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureBuildSizesInfoKHR
   {
     using NativeType = VkAccelerationStructureBuildSizesInfoKHR;
@@ -1135,29 +1203,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureBuildSizesInfoKHR *>( this );
     }
 
-    operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( accelerationStructureSize == rhs.accelerationStructureSize ) &&
-             ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -1184,29 +1264,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureBuildSizesInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const &
-                            accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureBuildSizesInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureBuildSizesInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureCreateInfoKHR
   {
     using NativeType = VkAccelerationStructureCreateInfoKHR;
@@ -1300,29 +1357,44 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( this );
     }
 
-    operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::DeviceAddress const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) &&
-             ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size ) && ( type == rhs.type ) &&
-             ( deviceAddress == rhs.deviceAddress );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -1352,32 +1424,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &
-                            accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR, seed, accelerationStructureCreateInfoKHR.createFlags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, accelerationStructureCreateInfoKHR.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.size );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR, seed, accelerationStructureCreateInfoKHR.type );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, accelerationStructureCreateInfoKHR.deviceAddress );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GeometryTrianglesNV
   {
     using NativeType = VkGeometryTrianglesNV;
@@ -1509,32 +1555,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryTrianglesNV *>( this );
     }
 
-    operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGeometryTrianglesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::IndexType const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       vertexData,
+                       vertexOffset,
+                       vertexCount,
+                       vertexStride,
+                       vertexFormat,
+                       indexData,
+                       indexOffset,
+                       indexCount,
+                       indexType,
+                       transformData,
+                       transformOffset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryTrianglesNV const & ) const = default;
 #else
     bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) &&
-             ( vertexOffset == rhs.vertexOffset ) && ( vertexCount == rhs.vertexCount ) &&
-             ( vertexStride == rhs.vertexStride ) && ( vertexFormat == rhs.vertexFormat ) &&
-             ( indexData == rhs.indexData ) && ( indexOffset == rhs.indexOffset ) && ( indexCount == rhs.indexCount ) &&
-             ( indexType == rhs.indexType ) && ( transformData == rhs.transformData ) &&
-             ( transformOffset == rhs.transformOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -1566,34 +1641,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeometryTrianglesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryTrianglesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryTrianglesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.vertexData );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.vertexCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexStride );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, geometryTrianglesNV.vertexFormat );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.indexData );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.indexOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.indexCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, geometryTrianglesNV.indexType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.transformData );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.transformOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GeometryAABBNV
   {
     using NativeType = VkGeometryAABBNV;
@@ -1659,28 +1706,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryAABBNV *>( this );
     }
 
-    operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGeometryAABBNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, aabbData, numAABBs, stride, offset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryAABBNV const & ) const = default;
 #else
     bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) &&
-             ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && ( offset == rhs.offset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -1705,26 +1766,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeometryAABBNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryAABBNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryAABBNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryAABBNV.aabbData );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.numAABBs );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.stride );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryAABBNV.offset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GeometryDataNV
   {
     using NativeType = VkGeometryDataNV;
@@ -1767,27 +1808,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryDataNV *>( this );
     }
 
-    operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGeometryDataNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const &, VULKAN_HPP_NAMESPACE::GeometryAABBNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( triangles, aabbs );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryDataNV const & ) const = default;
 #else
     bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -1802,22 +1853,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::GeometryDataNV>::value,
                             "GeometryDataNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryDataNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV, seed, geometryDataNV.triangles );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryAABBNV, seed, geometryDataNV.aabbs );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GeometryNV
   {
     using NativeType = VkGeometryNV;
@@ -1878,28 +1913,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryNV *>( this );
     }
 
-    operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGeometryNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::GeometryTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::GeometryDataNV const &,
+               VULKAN_HPP_NAMESPACE::GeometryFlagsKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, geometryType, geometry, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryNV const & ) const = default;
 #else
     bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) &&
-             ( geometry == rhs.geometry ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -1923,25 +1971,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeometryNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTypeKHR, seed, geometryNV.geometryType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryDataNV, seed, geometryNV.geometry );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryFlagsKHR, seed, geometryNV.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureInfoNV
   {
     using NativeType = VkAccelerationStructureInfoNV;
@@ -2047,29 +2076,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureInfoNV *>( this );
     }
 
-    operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV const &,
+               VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::GeometryNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) &&
-             ( instanceCount == rhs.instanceCount ) && ( geometryCount == rhs.geometryCount ) &&
-             ( pGeometries == rhs.pGeometries );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -2097,30 +2140,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV, seed, accelerationStructureInfoNV.type );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV, seed, accelerationStructureInfoNV.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.instanceCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.geometryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GeometryNV *, seed, accelerationStructureInfoNV.pGeometries );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureCreateInfoNV
   {
     using NativeType = VkAccelerationStructureCreateInfoNV;
@@ -2176,28 +2195,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( this );
     }
 
-    operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, compactedSize, info );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) &&
-             ( info == rhs.info );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -2222,26 +2253,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &
-                            accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoNV.compactedSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV, seed, accelerationStructureCreateInfoNV.info );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureDeviceAddressInfoKHR
   {
     using NativeType = VkAccelerationStructureDeviceAddressInfoKHR;
@@ -2292,27 +2303,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( this );
     }
 
-    operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, accelerationStructure );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -2337,27 +2360,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureDeviceAddressInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const &
-                            accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureDeviceAddressInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureDeviceAddressInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR,
-                             seed,
-                             accelerationStructureDeviceAddressInfoKHR.accelerationStructure );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureGeometryMotionTrianglesDataNV
   {
     using NativeType = VkAccelerationStructureGeometryMotionTrianglesDataNV;
@@ -2409,16 +2411,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV *>( this );
     }
 
-    operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, vertexData );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV;
     const void *                        pNext = {};
@@ -2474,27 +2488,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTransformMatrixKHR *>( this );
     }
 
-    operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkTransformMatrixKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper2D<float, 3, 4> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( matrix );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TransformMatrixKHR const & ) const = default;
 #else
     bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( matrix == rhs.matrix );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -2509,28 +2533,6 @@ namespace VULKAN_HPP_NAMESPACE
                             "TransformMatrixKHR is not nothrow_move_constructible!" );
   using TransformMatrixNV = TransformMatrixKHR;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    for ( size_t i = 0; i < 3; ++i )
-    {
-      for ( size_t j = 0; j < 4; ++j )
-      {
-        VULKAN_HPP_HASH_COMBINE( float, seed, transformMatrixKHR.matrix[i][j] );
-      }
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureInstanceKHR
   {
     using NativeType = VkAccelerationStructureInstanceKHR;
@@ -2611,30 +2613,47 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureInstanceKHR *>( this );
     }
 
-    operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureInstanceKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VkGeometryInstanceFlagsKHR const &,
+               uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( transform,
+                       instanceCustomIndex,
+                       mask,
+                       instanceShaderBindingTableRecordOffset,
+                       flags,
+                       accelerationStructureReference );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) &&
-             ( mask == rhs.mask ) &&
-             ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
-             ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -2656,29 +2675,6 @@ namespace VULKAN_HPP_NAMESPACE
     "AccelerationStructureInstanceKHR is not nothrow_move_constructible!" );
   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureInstanceKHR.transform );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceCustomIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.mask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset );
-    VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureInstanceKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureInstanceKHR.accelerationStructureReference );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureMatrixMotionInstanceNV
   {
     using NativeType = VkAccelerationStructureMatrixMotionInstanceNV;
@@ -2771,30 +2767,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureMatrixMotionInstanceNV *>( this );
     }
 
-    operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureMatrixMotionInstanceNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
+               VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VkGeometryInstanceFlagsKHR const &,
+               uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( transformT0,
+                       transformT1,
+                       instanceCustomIndex,
+                       mask,
+                       instanceShaderBindingTableRecordOffset,
+                       flags,
+                       accelerationStructureReference );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) &&
-             ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) &&
-             ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
-             ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -2817,32 +2832,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>::value,
     "AccelerationStructureMatrixMotionInstanceNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const &
-                            accelerationStructureMatrixMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT0 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT1 );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.mask );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset );
-    VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureMatrixMotionInstanceNV.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      uint64_t, seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureMemoryRequirementsInfoNV
   {
     using NativeType = VkAccelerationStructureMemoryRequirementsInfoNV;
@@ -2903,28 +2892,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( this );
     }
 
-    operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, type, accelerationStructure );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
-             ( accelerationStructure == rhs.accelerationStructure );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -2951,30 +2952,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureMemoryRequirementsInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const &
-                            accelerationStructureMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMemoryRequirementsInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMemoryRequirementsInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV,
-                             seed,
-                             accelerationStructureMemoryRequirementsInfoNV.type );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV,
-                             seed,
-                             accelerationStructureMemoryRequirementsInfoNV.accelerationStructure );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureMotionInfoNV
   {
     using NativeType = VkAccelerationStructureMotionInfoNV;
@@ -3030,28 +3007,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureMotionInfoNV *>( this );
     }
 
-    operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureMotionInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxInstances, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) &&
-             ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -3076,26 +3065,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureMotionInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const &
-                            accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMotionInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMotionInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMotionInfoNV.maxInstances );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV, seed, accelerationStructureMotionInfoNV.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SRTDataNV
   {
     using NativeType = VkSRTDataNV;
@@ -3247,30 +3216,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSRTDataNV *>( this );
     }
 
-    operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSRTDataNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SRTDataNV const & ) const = default;
 #else
     bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) &&
-             ( c == rhs.c ) && ( pvy == rhs.pvy ) && ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) &&
-             ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) && ( ty == rhs.ty ) &&
-             ( tz == rhs.tz );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -3299,36 +3290,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SRTDataNV>::value,
                             "SRTDataNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SRTDataNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sx );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.a );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.b );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvx );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sy );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.c );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvy );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sz );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvz );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qx );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qy );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qz );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qw );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tx );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.ty );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tz );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AccelerationStructureSRTMotionInstanceNV
   {
     using NativeType = VkAccelerationStructureSRTMotionInstanceNV;
@@ -3421,30 +3382,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureSRTMotionInstanceNV *>( this );
     }
 
-    operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureSRTMotionInstanceNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::SRTDataNV const &,
+               VULKAN_HPP_NAMESPACE::SRTDataNV const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VkGeometryInstanceFlagsKHR const &,
+               uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( transformT0,
+                       transformT1,
+                       instanceCustomIndex,
+                       mask,
+                       instanceShaderBindingTableRecordOffset,
+                       flags,
+                       accelerationStructureReference );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) &&
-             ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) &&
-             ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
-             ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -3467,31 +3447,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>::value,
     "AccelerationStructureSRTMotionInstanceNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const &
-                            accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT0 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT1 );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.mask );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset );
-    VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureSRTMotionInstanceNV.flags );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   union AccelerationStructureMotionInstanceDataNV
   {
     using NativeType = VkAccelerationStructureMotionInstanceDataNV;
@@ -3615,16 +3570,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureMotionInstanceNV *>( this );
     }
 
-    operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureMotionInstanceNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagsNV const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( type, flags, data );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV type =
       VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV::eStatic;
@@ -3686,27 +3653,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( this );
     }
 
-    operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAccelerationStructureVersionInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const uint8_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pVersionData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -3730,24 +3707,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureVersionInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const &
-                            accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureVersionInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureVersionInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, accelerationStructureVersionInfoKHR.pVersionData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AcquireNextImageInfoKHR
   {
     using NativeType = VkAcquireNextImageInfoKHR;
@@ -3823,29 +3782,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAcquireNextImageInfoKHR *>( this );
     }
 
-    operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAcquireNextImageInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SwapchainKHR const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               VULKAN_HPP_NAMESPACE::Fence const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AcquireNextImageInfoKHR const & ) const = default;
 #else
     bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) &&
-             ( timeout == rhs.timeout ) && ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) &&
-             ( deviceMask == rhs.deviceMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -3872,28 +3845,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AcquireNextImageInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireNextImageInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireNextImageInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, acquireNextImageInfoKHR.swapchain );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireNextImageInfoKHR.timeout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, acquireNextImageInfoKHR.semaphore );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, acquireNextImageInfoKHR.fence );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, acquireNextImageInfoKHR.deviceMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AcquireProfilingLockInfoKHR
   {
     using NativeType = VkAcquireProfilingLockInfoKHR;
@@ -3945,27 +3896,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( this );
     }
 
-    operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAcquireProfilingLockInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR const &,
+               uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, timeout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default;
 #else
     bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -3990,26 +3954,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AcquireProfilingLockInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireProfilingLockInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireProfilingLockInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR, seed, acquireProfilingLockInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireProfilingLockInfoKHR.timeout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AllocationCallbacks
   {
     using NativeType = VkAllocationCallbacks;
@@ -4086,29 +4030,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAllocationCallbacks *>( this );
     }
 
-    operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAllocationCallbacks *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<void * const &,
+               PFN_vkAllocationFunction const &,
+               PFN_vkReallocationFunction const &,
+               PFN_vkFreeFunction const &,
+               PFN_vkInternalAllocationNotification const &,
+               PFN_vkInternalFreeNotification const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AllocationCallbacks const & ) const = default;
 #else
     bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) &&
-             ( pfnReallocation == rhs.pfnReallocation ) && ( pfnFree == rhs.pfnFree ) &&
-             ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -4127,27 +4084,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AllocationCallbacks>::value,
                             "AllocationCallbacks is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( void *, seed, allocationCallbacks.pUserData );
-    VULKAN_HPP_HASH_COMBINE( PFN_vkAllocationFunction, seed, allocationCallbacks.pfnAllocation );
-    VULKAN_HPP_HASH_COMBINE( PFN_vkReallocationFunction, seed, allocationCallbacks.pfnReallocation );
-    VULKAN_HPP_HASH_COMBINE( PFN_vkFreeFunction, seed, allocationCallbacks.pfnFree );
-    VULKAN_HPP_HASH_COMBINE( PFN_vkInternalAllocationNotification, seed, allocationCallbacks.pfnInternalAllocation );
-    VULKAN_HPP_HASH_COMBINE( PFN_vkInternalFreeNotification, seed, allocationCallbacks.pfnInternalFree );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ComponentMapping
   {
     using NativeType = VkComponentMapping;
@@ -4206,27 +4142,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkComponentMapping *>( this );
     }
 
-    operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkComponentMapping *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
+               VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
+               VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
+               VULKAN_HPP_NAMESPACE::ComponentSwizzle const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( r, g, b, a );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ComponentMapping const & ) const = default;
 #else
     bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -4243,24 +4192,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ComponentMapping>::value,
                             "ComponentMapping is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ComponentMapping>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.r );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.g );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.b );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.a );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct AndroidHardwareBufferFormatProperties2ANDROID
   {
@@ -4312,32 +4243,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID *>( this );
     }
 
-    operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       format,
+                       externalFormat,
+                       formatFeatures,
+                       samplerYcbcrConversionComponents,
+                       suggestedYcbcrModel,
+                       suggestedYcbcrRange,
+                       suggestedXChromaOffset,
+                       suggestedYChromaOffset );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) &&
-             ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
-             ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
-             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
-             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) &&
-             ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -4369,45 +4323,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferFormatProperties2ANDROID;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const &
-                            androidHardwareBufferFormatProperties2ANDROID ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatProperties2ANDROID.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatProperties2ANDROID.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatProperties2ANDROID.format );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR,
-                             seed,
-                             androidHardwareBufferFormatProperties2ANDROID.formatFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
-                             seed,
-                             androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion,
-                             seed,
-                             androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrRange,
-                             seed,
-                             androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation,
-                             seed,
-                             androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation,
-                             seed,
-                             androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -4461,32 +4376,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>( this );
     }
 
-    operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       format,
+                       externalFormat,
+                       formatFeatures,
+                       samplerYcbcrConversionComponents,
+                       suggestedYcbcrModel,
+                       suggestedYcbcrRange,
+                       suggestedXChromaOffset,
+                       suggestedYChromaOffset );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) &&
-             ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
-             ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
-             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
-             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) &&
-             ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -4518,41 +4456,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferFormatPropertiesANDROID;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const &
-                            androidHardwareBufferFormatPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatPropertiesANDROID.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatPropertiesANDROID.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatPropertiesANDROID.format );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
-                             seed,
-                             androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion,
-                             seed,
-                             androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -4590,28 +4493,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID *>( this );
     }
 
-    operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, allocationSize, memoryTypeBits );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) &&
-             ( memoryTypeBits == rhs.memoryTypeBits );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -4636,27 +4551,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferPropertiesANDROID;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const &
-                            androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferPropertiesANDROID.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferPropertiesANDROID.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, androidHardwareBufferPropertiesANDROID.allocationSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -4691,28 +4585,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>( this );
     }
 
-    operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, androidHardwareBufferUsage );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -4735,25 +4638,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferUsageANDROID;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const &
-                            androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferUsageANDROID.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferUsageANDROID.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -4809,27 +4693,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( this );
     }
 
-    operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR const &,
+               struct ANativeWindow * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, window );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -4853,27 +4750,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidSurfaceCreateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidSurfaceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, androidSurfaceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR, seed, androidSurfaceCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( struct ANativeWindow *, seed, androidSurfaceCreateInfoKHR.window );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ApplicationInfo
@@ -4949,29 +4825,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkApplicationInfo *>( this );
     }
 
-    operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkApplicationInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const char * const &,
+               uint32_t const &,
+               const char * const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ApplicationInfo const & ) const = default;
 #else
     bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pApplicationName == rhs.pApplicationName ) &&
-             ( applicationVersion == rhs.applicationVersion ) && ( pEngineName == rhs.pEngineName ) &&
-             ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -4997,27 +4887,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ApplicationInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ApplicationInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, applicationInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, applicationInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pApplicationName );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.applicationVersion );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pEngineName );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.engineVersion );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.apiVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentDescription
   {
     using NativeType = VkAttachmentDescription;
@@ -5125,30 +4994,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentDescription *>( this );
     }
 
-    operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentDescription *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+               VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+               VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+               VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentDescription const & ) const = default;
 #else
     bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) &&
-             ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) &&
-             ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) &&
-             ( finalLayout == rhs.finalLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -5170,30 +5055,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentDescription>::value,
                             "AttachmentDescription is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescription>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription.samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.loadOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.storeOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.stencilLoadOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.stencilStoreOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.initialLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.finalLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentDescription2
   {
     using NativeType = VkAttachmentDescription2;
@@ -5310,30 +5171,57 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentDescription2 *>( this );
     }
 
-    operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentDescription2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+               VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+               VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+               VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       format,
+                       samples,
+                       loadOp,
+                       storeOp,
+                       stencilLoadOp,
+                       stencilStoreOp,
+                       initialLayout,
+                       finalLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentDescription2 const & ) const = default;
 #else
     bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) &&
-             ( samples == rhs.samples ) && ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) &&
-             ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) &&
-             ( initialLayout == rhs.initialLayout ) && ( finalLayout == rhs.finalLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -5365,32 +5253,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentDescription2KHR = AttachmentDescription2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescription2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentDescription2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription2.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription2.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription2.samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.loadOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.storeOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.stencilLoadOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.stencilStoreOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.initialLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.finalLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentDescriptionStencilLayout
   {
     using NativeType = VkAttachmentDescriptionStencilLayout;
@@ -5448,28 +5310,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentDescriptionStencilLayout *>( this );
     }
 
-    operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentDescriptionStencilLayout *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default;
 #else
     bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) &&
-             ( stencilFinalLayout == rhs.stencilFinalLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -5495,27 +5369,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const &
-                            attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescriptionStencilLayout.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentDescriptionStencilLayout.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilInitialLayout );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilFinalLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentReference
   {
     using NativeType = VkAttachmentReference;
@@ -5558,27 +5411,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentReference *>( this );
     }
 
-    operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentReference *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( attachment, layout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentReference const & ) const = default;
 #else
     bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( attachment == rhs.attachment ) && ( layout == rhs.layout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -5593,23 +5456,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentReference>::value,
                             "AttachmentReference is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReference>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference.attachment );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference.layout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentReference2
   {
     using NativeType = VkAttachmentReference2;
@@ -5670,28 +5516,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentReference2 *>( this );
     }
 
-    operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentReference2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::ImageAspectFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, attachment, layout, aspectMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentReference2 const & ) const = default;
 #else
     bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) &&
-             ( layout == rhs.layout ) && ( aspectMask == rhs.aspectMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -5716,26 +5575,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentReference2KHR = AttachmentReference2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReference2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReference2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentReference2.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference2.attachment );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference2.layout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, attachmentReference2.aspectMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentReferenceStencilLayout
   {
     using NativeType = VkAttachmentReferenceStencilLayout;
@@ -5782,27 +5621,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentReferenceStencilLayout *>( this );
     }
 
-    operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentReferenceStencilLayout *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stencilLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default;
 #else
     bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -5827,25 +5676,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReferenceStencilLayout.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentReferenceStencilLayout.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReferenceStencilLayout.stencilLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentSampleCountInfoAMD
   {
     using NativeType = VkAttachmentSampleCountInfoAMD;
@@ -5931,29 +5761,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentSampleCountInfoAMD *>( this );
     }
 
-    operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentSampleCountInfoAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SampleCountFlagBits * const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default;
 #else
     bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
-             ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) &&
-             ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -5981,28 +5823,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentSampleCountInfoAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentSampleCountInfoAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleCountInfoAMD.colorAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SampleCountFlagBits *, seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct Extent2D
   {
     using NativeType = VkExtent2D;
@@ -6040,27 +5860,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExtent2D *>( this );
     }
 
-    operator VkExtent2D &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExtent2D &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExtent2D *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( width, height );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Extent2D const & ) const = default;
 #else
     bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( width == rhs.width ) && ( height == rhs.height );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6075,22 +5905,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Extent2D>::value,
                             "Extent2D is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Extent2D>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.width );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.height );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SampleLocationEXT
   {
     using NativeType = VkSampleLocationEXT;
@@ -6130,27 +5944,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSampleLocationEXT *>( this );
     }
 
-    operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSampleLocationEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<float const &, float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( x, y );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SampleLocationEXT const & ) const = default;
 #else
     bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( x == rhs.x ) && ( y == rhs.y );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6165,22 +5989,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SampleLocationEXT>::value,
                             "SampleLocationEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.x );
-    VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.y );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SampleLocationsInfoEXT
   {
     using NativeType = VkSampleLocationsInfoEXT;
@@ -6276,30 +6084,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSampleLocationsInfoEXT *>( this );
     }
 
-    operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSampleLocationsInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SampleLocationEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SampleLocationsInfoEXT const & ) const = default;
 #else
     bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) &&
-             ( sampleLocationGridSize == rhs.sampleLocationGridSize ) &&
-             ( sampleLocationsCount == rhs.sampleLocationsCount ) && ( pSampleLocations == rhs.pSampleLocations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6325,29 +6146,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SampleLocationsInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sampleLocationsInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, sampleLocationsInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, sampleLocationsInfoEXT.sampleLocationsPerPixel );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, sampleLocationsInfoEXT.sampleLocationGridSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sampleLocationsInfoEXT.sampleLocationsCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SampleLocationEXT *, seed, sampleLocationsInfoEXT.pSampleLocations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct AttachmentSampleLocationsEXT
   {
     using NativeType = VkAttachmentSampleLocationsEXT;
@@ -6392,27 +6190,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentSampleLocationsEXT *>( this );
     }
 
-    operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkAttachmentSampleLocationsEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( attachmentIndex, sampleLocationsInfo );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default;
 #else
     bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6429,24 +6237,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>::value,
     "AttachmentSampleLocationsEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleLocationsEXT.attachmentIndex );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, attachmentSampleLocationsEXT.sampleLocationsInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BaseInStructure
   {
     using NativeType = VkBaseInStructure;
@@ -6480,27 +6270,38 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBaseInStructure *>( this );
     }
 
-    operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBaseInStructure *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const struct VULKAN_HPP_NAMESPACE::BaseInStructure * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BaseInStructure const & ) const = default;
 #else
     bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6515,22 +6316,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BaseInStructure>::value,
                             "BaseInStructure is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BaseInStructure>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseInStructure.sType );
-    VULKAN_HPP_HASH_COMBINE( const struct VULKAN_HPP_NAMESPACE::BaseInStructure *, seed, baseInStructure.pNext );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BaseOutStructure
   {
     using NativeType = VkBaseOutStructure;
@@ -6564,27 +6349,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBaseOutStructure *>( this );
     }
 
-    operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBaseOutStructure *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, struct VULKAN_HPP_NAMESPACE::BaseOutStructure * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BaseOutStructure const & ) const = default;
 #else
     bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6599,22 +6394,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BaseOutStructure>::value,
                             "BaseOutStructure is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BaseOutStructure>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseOutStructure.sType );
-    VULKAN_HPP_HASH_COMBINE( struct VULKAN_HPP_NAMESPACE::BaseOutStructure *, seed, baseOutStructure.pNext );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindAccelerationStructureMemoryInfoNV
   {
     using NativeType = VkBindAccelerationStructureMemoryInfoNV;
@@ -6723,30 +6502,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( this );
     }
 
-    operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default;
 #else
     bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) &&
-             ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
-             ( pDeviceIndices == rhs.pDeviceIndices );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6774,31 +6566,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BindAccelerationStructureMemoryInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const &
-                            bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindAccelerationStructureMemoryInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindAccelerationStructureMemoryInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV,
-                             seed,
-                             bindAccelerationStructureMemoryInfoNV.accelerationStructure );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindAccelerationStructureMemoryInfoNV.memory );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindAccelerationStructureMemoryInfoNV.memoryOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindBufferMemoryDeviceGroupInfo
   {
     using NativeType = VkBindBufferMemoryDeviceGroupInfo;
@@ -6869,28 +6636,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>( this );
     }
 
-    operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default;
 #else
     bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
-             ( pDeviceIndices == rhs.pDeviceIndices );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -6916,26 +6695,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryDeviceGroupInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryDeviceGroupInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindBufferMemoryInfo
   {
     using NativeType = VkBindBufferMemoryInfo;
@@ -6995,28 +6754,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindBufferMemoryInfo *>( this );
     }
 
-    operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindBufferMemoryInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, buffer, memory, memoryOffset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindBufferMemoryInfo const & ) const = default;
 #else
     bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) &&
-             ( memoryOffset == rhs.memoryOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7041,26 +6813,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bindBufferMemoryInfo.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindBufferMemoryInfo.memory );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindBufferMemoryInfo.memoryOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct Offset2D
   {
     using NativeType = VkOffset2D;
@@ -7098,27 +6850,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkOffset2D *>( this );
     }
 
-    operator VkOffset2D &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkOffset2D &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkOffset2D *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<int32_t const &, int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( x, y );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Offset2D const & ) const = default;
 #else
     bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( x == rhs.x ) && ( y == rhs.y );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7133,22 +6895,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Offset2D>::value,
                             "Offset2D is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Offset2D>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.x );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.y );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct Rect2D
   {
     using NativeType = VkRect2D;
@@ -7187,27 +6933,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRect2D *>( this );
     }
 
-    operator VkRect2D &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRect2D &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRect2D *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Offset2D const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( offset, extent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Rect2D const & ) const = default;
 #else
     bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( offset == rhs.offset ) && ( extent == rhs.extent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7222,22 +6978,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Rect2D>::value,
                             "Rect2D is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Rect2D>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rect2D.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rect2D.extent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindImageMemoryDeviceGroupInfo
   {
     using NativeType = VkBindImageMemoryDeviceGroupInfo;
@@ -7343,30 +7083,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>( this );
     }
 
-    operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default;
 #else
     bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
-             ( pDeviceIndices == rhs.pDeviceIndices ) &&
-             ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) &&
-             ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7394,28 +7147,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryDeviceGroupInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryDeviceGroupInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Rect2D *, seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindImageMemoryInfo
   {
     using NativeType = VkBindImageMemoryInfo;
@@ -7475,28 +7206,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImageMemoryInfo *>( this );
     }
 
-    operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindImageMemoryInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, image, memory, memoryOffset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImageMemoryInfo const & ) const = default;
 #else
     bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) &&
-             ( memoryOffset == rhs.memoryOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7521,26 +7265,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindImageMemoryInfoKHR = BindImageMemoryInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, bindImageMemoryInfo.image );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindImageMemoryInfo.memory );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindImageMemoryInfo.memoryOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindImageMemorySwapchainInfoKHR
   {
     using NativeType = VkBindImageMemorySwapchainInfoKHR;
@@ -7593,28 +7317,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>( this );
     }
 
-    operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SwapchainKHR const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, swapchain, imageIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default;
 #else
     bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) &&
-             ( imageIndex == rhs.imageIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7639,26 +7375,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BindImageMemorySwapchainInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemorySwapchainInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemorySwapchainInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, bindImageMemorySwapchainInfoKHR.swapchain );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemorySwapchainInfoKHR.imageIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindImagePlaneMemoryInfo
   {
     using NativeType = VkBindImagePlaneMemoryInfo;
@@ -7703,27 +7419,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImagePlaneMemoryInfo *>( this );
     }
 
-    operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindImagePlaneMemoryInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, planeAspect );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default;
 #else
     bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7747,24 +7475,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImagePlaneMemoryInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImagePlaneMemoryInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, bindImagePlaneMemoryInfo.planeAspect );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindIndexBufferIndirectCommandNV
   {
     using NativeType = VkBindIndexBufferIndirectCommandNV;
@@ -7818,27 +7528,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindIndexBufferIndirectCommandNV *>( this );
     }
 
-    operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindIndexBufferIndirectCommandNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &, uint32_t const &, VULKAN_HPP_NAMESPACE::IndexType const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( bufferAddress, size, indexType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default;
 #else
     bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7856,26 +7576,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>::value,
     "BindIndexBufferIndirectCommandNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindIndexBufferIndirectCommandNV.bufferAddress );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindIndexBufferIndirectCommandNV.size );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, bindIndexBufferIndirectCommandNV.indexType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindShaderGroupIndirectCommandNV
   {
     using NativeType = VkBindShaderGroupIndirectCommandNV;
@@ -7910,27 +7610,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindShaderGroupIndirectCommandNV *>( this );
     }
 
-    operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindShaderGroupIndirectCommandNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( groupIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default;
 #else
     bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( groupIndex == rhs.groupIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -7946,23 +7656,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>::value,
     "BindShaderGroupIndirectCommandNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindShaderGroupIndirectCommandNV.groupIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseMemoryBind
   {
     using NativeType = VkSparseMemoryBind;
@@ -8031,28 +7724,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseMemoryBind *>( this );
     }
 
-    operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseMemoryBind *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( resourceOffset, size, memory, memoryOffset, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseMemoryBind const & ) const = default;
 #else
     bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) &&
-             ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8070,25 +7776,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseMemoryBind>::value,
                             "SparseMemoryBind is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.resourceOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.size );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseMemoryBind.memory );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.memoryOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseMemoryBind.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseBufferMemoryBindInfo
   {
     using NativeType = VkSparseBufferMemoryBindInfo;
@@ -8160,27 +7847,39 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseBufferMemoryBindInfo *>( this );
     }
 
-    operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseBufferMemoryBindInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SparseMemoryBind * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( buffer, bindCount, pBinds );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default;
 #else
     bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8197,24 +7896,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>::value,
                             "SparseBufferMemoryBindInfo is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, sparseBufferMemoryBindInfo.buffer );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseBufferMemoryBindInfo.bindCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseBufferMemoryBindInfo.pBinds );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseImageOpaqueMemoryBindInfo
   {
     using NativeType = VkSparseImageOpaqueMemoryBindInfo;
@@ -8287,27 +7968,39 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo *>( this );
     }
 
-    operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Image const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SparseMemoryBind * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( image, bindCount, pBinds );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default;
 #else
     bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8325,26 +8018,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>::value,
     "SparseImageOpaqueMemoryBindInfo is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageOpaqueMemoryBindInfo.image );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageOpaqueMemoryBindInfo.bindCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseImageOpaqueMemoryBindInfo.pBinds );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageSubresource
   {
     using NativeType = VkImageSubresource;
@@ -8394,27 +8067,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSubresource *>( this );
     }
 
-    operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageSubresource *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( aspectMask, mipLevel, arrayLayer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSubresource const & ) const = default;
 #else
     bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8430,23 +8113,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresource>::value,
                             "ImageSubresource is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresource>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresource.aspectMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.mipLevel );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.arrayLayer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct Offset3D
   {
     using NativeType = VkOffset3D;
@@ -8493,27 +8159,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkOffset3D *>( this );
     }
 
-    operator VkOffset3D &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkOffset3D &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkOffset3D *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<int32_t const &, int32_t const &, int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( x, y, z );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Offset3D const & ) const = default;
 #else
     bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8529,23 +8205,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Offset3D>::value,
                             "Offset3D is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Offset3D>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.x );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.y );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.z );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct Extent3D
   {
     using NativeType = VkExtent3D;
@@ -8595,27 +8254,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExtent3D *>( this );
     }
 
-    operator VkExtent3D &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExtent3D &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExtent3D *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( width, height, depth );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Extent3D const & ) const = default;
 #else
     bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8631,23 +8300,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Extent3D>::value,
                             "Extent3D is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Extent3D>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.width );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.height );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.depth );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseImageMemoryBind
   {
     using NativeType = VkSparseImageMemoryBind;
@@ -8727,28 +8379,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryBind *>( this );
     }
 
-    operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseImageMemoryBind *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresource const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( subresource, offset, extent, memory, memoryOffset, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryBind const & ) const = default;
 #else
     bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) &&
-             ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8767,27 +8433,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>::value,
                             "SparseImageMemoryBind is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresource, seed, sparseImageMemoryBind.subresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, sparseImageMemoryBind.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageMemoryBind.extent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseImageMemoryBind.memory );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryBind.memoryOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseImageMemoryBind.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseImageMemoryBindInfo
   {
     using NativeType = VkSparseImageMemoryBindInfo;
@@ -8859,27 +8504,39 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryBindInfo *>( this );
     }
 
-    operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseImageMemoryBindInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Image const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( image, bindCount, pBinds );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryBindInfo const & ) const = default;
 #else
     bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -8896,25 +8553,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>::value,
                             "SparseImageMemoryBindInfo is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageMemoryBindInfo.image );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryBindInfo.bindCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind *, seed, sparseImageMemoryBindInfo.pBinds );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindSparseInfo
   {
     using NativeType = VkBindSparseInfo;
@@ -9115,32 +8753,59 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindSparseInfo *>( this );
     }
 
-    operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindSparseInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Semaphore * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       waitSemaphoreCount,
+                       pWaitSemaphores,
+                       bufferBindCount,
+                       pBufferBinds,
+                       imageOpaqueBindCount,
+                       pImageOpaqueBinds,
+                       imageBindCount,
+                       pImageBinds,
+                       signalSemaphoreCount,
+                       pSignalSemaphores );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindSparseInfo const & ) const = default;
 #else
     bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
-             ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) &&
-             ( pBufferBinds == rhs.pBufferBinds ) && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) &&
-             ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) && ( imageBindCount == rhs.imageBindCount ) &&
-             ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) &&
-             ( pSignalSemaphores == rhs.pSignalSemaphores );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -9171,35 +8836,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BindSparseInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindSparseInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindSparseInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindSparseInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.waitSemaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pWaitSemaphores );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.bufferBindCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo *, seed, bindSparseInfo.pBufferBinds );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageOpaqueBindCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo *, seed, bindSparseInfo.pImageOpaqueBinds );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageBindCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo *, seed, bindSparseInfo.pImageBinds );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.signalSemaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pSignalSemaphores );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BindVertexBufferIndirectCommandNV
   {
     using NativeType = VkBindVertexBufferIndirectCommandNV;
@@ -9251,27 +8887,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindVertexBufferIndirectCommandNV *>( this );
     }
 
-    operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBindVertexBufferIndirectCommandNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( bufferAddress, size, stride );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default;
 #else
     bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -9289,25 +8935,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>::value,
     "BindVertexBufferIndirectCommandNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const &
-                            bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindVertexBufferIndirectCommandNV.bufferAddress );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.size );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.stride );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageSubresourceLayers
   {
     using NativeType = VkImageSubresourceLayers;
@@ -9365,28 +8992,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSubresourceLayers *>( this );
     }
 
-    operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageSubresourceLayers *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSubresourceLayers const & ) const = default;
 #else
     bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) &&
-             ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -9404,25 +9040,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>::value,
                             "ImageSubresourceLayers is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceLayers.aspectMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.mipLevel );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.baseArrayLayer );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.layerCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageBlit2KHR
   {
     using NativeType = VkImageBlit2KHR;
@@ -9493,29 +9110,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageBlit2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageBlit2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageBlit2KHR *>( this );
     }
 
-    operator VkImageBlit2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageBlit2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageBlit2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageBlit2KHR const & ) const = default;
 #else
     bool operator==( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
-             ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) &&
-             ( dstOffsets == rhs.dstOffsets );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -9540,32 +9170,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageBlit2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageBlit2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2KHR const & imageBlit2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageBlit2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageBlit2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.srcSubresource );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.srcOffsets[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.dstSubresource );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.dstOffsets[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BlitImageInfo2KHR
   {
     using NativeType = VkBlitImageInfo2KHR;
@@ -9688,30 +9292,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBlitImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBlitImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBlitImageInfo2KHR *>( this );
     }
 
-    operator VkBlitImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBlitImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBlitImageInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ImageBlit2KHR * const &,
+               VULKAN_HPP_NAMESPACE::Filter const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BlitImageInfo2KHR const & ) const = default;
 #else
     bool operator==( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
-             ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
-             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
-             ( pRegions == rhs.pRegions ) && ( filter == rhs.filter );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -9739,29 +9359,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BlitImageInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR const & blitImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, blitImageInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, blitImageInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.srcImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.srcImageLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.dstImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.dstImageLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, blitImageInfo2KHR.regionCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageBlit2KHR *, seed, blitImageInfo2KHR.pRegions );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, blitImageInfo2KHR.filter );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct BufferCollectionBufferCreateInfoFUCHSIA
   {
@@ -9820,28 +9417,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA *>( this );
     }
 
-    operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, collection, index );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
-             ( index == rhs.index );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -9866,27 +9475,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionBufferCreateInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const &
-                            bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionBufferCreateInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionBufferCreateInfoFUCHSIA.collection );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionBufferCreateInfoFUCHSIA.index );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -9974,30 +9562,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCollectionConstraintsInfoFUCHSIA *>( this );
     }
 
-    operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       minBufferCount,
+                       maxBufferCount,
+                       minBufferCountForCamping,
+                       minBufferCountForDedicatedSlack,
+                       minBufferCountForSharedSlack );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) &&
-             ( maxBufferCount == rhs.maxBufferCount ) && ( minBufferCountForCamping == rhs.minBufferCountForCamping ) &&
-             ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) &&
-             ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -10025,29 +9632,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionConstraintsInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &
-                            bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionConstraintsInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionConstraintsInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -10096,28 +9680,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( this );
     }
 
-    operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, zx_handle_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, collectionToken );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -10140,25 +9733,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionCreateInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &
-                            bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionCreateInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionCreateInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, bufferCollectionCreateInfoFUCHSIA.collectionToken );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -10218,28 +9792,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA *>( this );
     }
 
-    operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, collection, index );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
-             ( index == rhs.index );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -10264,27 +9850,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionImageCreateInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const &
-                            bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionImageCreateInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionImageCreateInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionImageCreateInfoFUCHSIA.collection );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionImageCreateInfoFUCHSIA.index );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -10329,27 +9894,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSysmemColorSpaceFUCHSIA *>( this );
     }
 
-    operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSysmemColorSpaceFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, colorSpace );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default;
 #  else
     bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -10371,25 +9946,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SysmemColorSpaceFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sysmemColorSpaceFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, sysmemColorSpaceFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sysmemColorSpaceFUCHSIA.colorSpace );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -10531,34 +10087,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIA *>( this );
     }
 
-    operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const &,
+               VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       memoryTypeBits,
+                       bufferCount,
+                       createInfoIndex,
+                       sysmemPixelFormat,
+                       formatFeatures,
+                       sysmemColorSpaceIndex,
+                       samplerYcbcrConversionComponents,
+                       suggestedYcbcrModel,
+                       suggestedYcbcrRange,
+                       suggestedXChromaOffset,
+                       suggestedYChromaOffset );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) &&
-             ( bufferCount == rhs.bufferCount ) && ( createInfoIndex == rhs.createInfoIndex ) &&
-             ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
-             ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) &&
-             ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
-             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
-             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) &&
-             ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -10592,43 +10175,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionPropertiesFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const &
-                            bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionPropertiesFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, bufferCollectionPropertiesFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.bufferCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferCollectionPropertiesFUCHSIA.formatFeatures );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA, seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
-                             seed,
-                             bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct BufferCreateInfo
@@ -10743,30 +10289,44 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCreateInfo *>( this );
     }
 
-    operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::BufferCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::BufferUsageFlags const &,
+               VULKAN_HPP_NAMESPACE::SharingMode const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCreateInfo const & ) const = default;
 #else
     bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) &&
-             ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) &&
-             ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
-             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -10793,28 +10353,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, bufferCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCreateInfo.size );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, bufferCreateInfo.usage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, bufferCreateInfo.sharingMode );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCreateInfo.queueFamilyIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bufferCreateInfo.pQueueFamilyIndices );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct BufferConstraintsInfoFUCHSIA
   {
@@ -10880,29 +10418,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( this );
     }
 
-    operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferConstraintsInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::BufferCreateInfo const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) &&
-             ( requiredFormatFeatures == rhs.requiredFormatFeatures ) &&
-             ( bufferCollectionConstraints == rhs.bufferCollectionConstraints );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -10927,30 +10477,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferConstraintsInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferConstraintsInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferConstraintsInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateInfo, seed, bufferConstraintsInfoFUCHSIA.createInfo );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA,
-                             seed,
-                             bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct BufferCopy
@@ -11001,27 +10527,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCopy *>( this );
     }
 
-    operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCopy *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( srcOffset, dstOffset, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCopy const & ) const = default;
 #else
     bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -11037,23 +10575,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferCopy>::value,
                             "BufferCopy is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCopy>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.srcOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.dstOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferCopy2KHR
   {
     using NativeType = VkBufferCopy2KHR;
@@ -11113,28 +10634,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCopy2KHR *>( this );
     }
 
-    operator VkBufferCopy2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferCopy2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferCopy2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcOffset, dstOffset, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCopy2KHR const & ) const = default;
 #else
     bool operator==( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) &&
-             ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -11158,25 +10692,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferCopy2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCopy2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2KHR const & bufferCopy2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCopy2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCopy2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.srcOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.dstOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferDeviceAddressCreateInfoEXT
   {
     using NativeType = VkBufferDeviceAddressCreateInfoEXT;
@@ -11222,27 +10737,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>( this );
     }
 
-    operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceAddress const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceAddress );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default;
 #else
     bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -11266,26 +10793,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferDeviceAddressCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bufferDeviceAddressCreateInfoEXT.deviceAddress );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferDeviceAddressInfo
   {
     using NativeType = VkBufferDeviceAddressInfo;
@@ -11328,27 +10835,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferDeviceAddressInfo *>( this );
     }
 
-    operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferDeviceAddressInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, buffer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferDeviceAddressInfo const & ) const = default;
 #else
     bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -11373,24 +10890,6 @@ namespace VULKAN_HPP_NAMESPACE
   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferDeviceAddressInfo.buffer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferImageCopy
   {
     using NativeType = VkBufferImageCopy;
@@ -11467,29 +10966,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferImageCopy *>( this );
     }
 
-    operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferImageCopy *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferImageCopy const & ) const = default;
 #else
     bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) &&
-             ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) &&
-             ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -11508,26 +11020,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferImageCopy>::value,
                             "BufferImageCopy is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferImageCopy>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy.bufferOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferRowLength );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferImageHeight );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy.imageSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy.imageOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy.imageExtent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferImageCopy2KHR
   {
     using NativeType = VkBufferImageCopy2KHR;
@@ -11614,30 +11106,45 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferImageCopy2KHR *>( this );
     }
 
-    operator VkBufferImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferImageCopy2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferImageCopy2KHR const & ) const = default;
 #else
     bool operator==( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) &&
-             ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) &&
-             ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) &&
-             ( imageExtent == rhs.imageExtent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -11664,29 +11171,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferImageCopy2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR const & bufferImageCopy2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferImageCopy2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferImageCopy2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy2KHR.bufferOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferRowLength );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferImageHeight );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy2KHR.imageSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy2KHR.imageOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy2KHR.imageExtent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferMemoryBarrier
   {
     using NativeType = VkBufferMemoryBarrier;
@@ -11781,30 +11265,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferMemoryBarrier *>( this );
     }
 
-    operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferMemoryBarrier *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferMemoryBarrier const & ) const = default;
 #else
     bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
-             ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
-             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) &&
-             ( offset == rhs.offset ) && ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -11832,30 +11332,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferMemoryBarrier;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.dstAccessMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.srcQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.dstQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferMemoryBarrier2KHR
   {
     using NativeType = VkBufferMemoryBarrier2KHR;
@@ -11970,31 +11446,57 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferMemoryBarrier2KHR *>( this );
     }
 
-    operator VkBufferMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferMemoryBarrier2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       srcStageMask,
+                       srcAccessMask,
+                       dstStageMask,
+                       dstAccessMask,
+                       srcQueueFamilyIndex,
+                       dstQueueFamilyIndex,
+                       buffer,
+                       offset,
+                       size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferMemoryBarrier2KHR const & ) const = default;
 #else
     bool operator==( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
-             ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
-             ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
-             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) &&
-             ( offset == rhs.offset ) && ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12025,32 +11527,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferMemoryBarrier2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR const & bufferMemoryBarrier2KHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.srcStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.dstStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.dstAccessMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.srcQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.dstQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier2KHR.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferMemoryRequirementsInfo2
   {
     using NativeType = VkBufferMemoryRequirementsInfo2;
@@ -12095,27 +11571,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( this );
     }
 
-    operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, buffer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default;
 #else
     bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12140,24 +11626,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryRequirementsInfo2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryRequirementsInfo2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryRequirementsInfo2.buffer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferOpaqueCaptureAddressCreateInfo
   {
     using NativeType = VkBufferOpaqueCaptureAddressCreateInfo;
@@ -12204,27 +11672,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo *>( this );
     }
 
-    operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, opaqueCaptureAddress );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default;
 #else
     bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12249,24 +11727,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const &
-                            bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferOpaqueCaptureAddressCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferOpaqueCaptureAddressCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct BufferViewCreateInfo
   {
     using NativeType = VkBufferViewCreateInfo;
@@ -12344,28 +11804,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferViewCreateInfo *>( this );
     }
 
-    operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkBufferViewCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::BufferViewCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, buffer, format, offset, range );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferViewCreateInfo const & ) const = default;
 #else
     bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) &&
-             ( format == rhs.format ) && ( offset == rhs.offset ) && ( range == rhs.range );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12391,28 +11866,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferViewCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferViewCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferViewCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferViewCreateFlags, seed, bufferViewCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferViewCreateInfo.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, bufferViewCreateInfo.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.range );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CalibratedTimestampInfoEXT
   {
     using NativeType = VkCalibratedTimestampInfoEXT;
@@ -12458,27 +11911,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( this );
     }
 
-    operator VkCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCalibratedTimestampInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::TimeDomainEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, timeDomain );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CalibratedTimestampInfoEXT const & ) const = default;
 #else
     bool operator==( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12501,24 +11966,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CalibratedTimestampInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, calibratedTimestampInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, calibratedTimestampInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TimeDomainEXT, seed, calibratedTimestampInfoEXT.timeDomain );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CheckpointData2NV
   {
     using NativeType = VkCheckpointData2NV;
@@ -12548,28 +11995,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCheckpointData2NV *>( this );
     }
 
-    operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCheckpointData2NV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stage, pCheckpointMarker );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CheckpointData2NV const & ) const = default;
 #else
     bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) &&
-             ( pCheckpointMarker == rhs.pCheckpointMarker );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12592,24 +12051,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CheckpointData2NV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointData2NV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, checkpointData2NV.stage );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pCheckpointMarker );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CheckpointDataNV
   {
     using NativeType = VkCheckpointDataNV;
@@ -12640,28 +12081,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCheckpointDataNV *>( this );
     }
 
-    operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCheckpointDataNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlagBits const &,
+               void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stage, pCheckpointMarker );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CheckpointDataNV const & ) const = default;
 #else
     bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) &&
-             ( pCheckpointMarker == rhs.pCheckpointMarker );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12684,24 +12137,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CheckpointDataNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointDataNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits, seed, checkpointDataNV.stage );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pCheckpointMarker );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   union ClearColorValue
   {
     using NativeType = VkClearColorValue;
@@ -12788,27 +12223,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkClearDepthStencilValue *>( this );
     }
 
-    operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkClearDepthStencilValue *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<float const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( depth, stencil );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ClearDepthStencilValue const & ) const = default;
 #else
     bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( depth == rhs.depth ) && ( stencil == rhs.stencil );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -12824,23 +12269,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>::value,
                             "ClearDepthStencilValue is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( float, seed, clearDepthStencilValue.depth );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearDepthStencilValue.stencil );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   union ClearValue
   {
     using NativeType = VkClearValue;
@@ -12938,16 +12366,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkClearAttachment *>( this );
     }
 
-    operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkClearAttachment *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ClearValue const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( aspectMask, colorAttachment, clearValue );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask      = {};
     uint32_t                               colorAttachment = {};
@@ -13007,27 +12446,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkClearRect *>( this );
     }
 
-    operator VkClearRect &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkClearRect &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkClearRect *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Rect2D const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( rect, baseArrayLayer, layerCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ClearRect const & ) const = default;
 #else
-    bool                     operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13043,23 +12492,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClearRect>::value,
                             "ClearRect is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ClearRect>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, clearRect.rect );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.baseArrayLayer );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.layerCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CoarseSampleLocationNV
   {
     using NativeType = VkCoarseSampleLocationNV;
@@ -13107,27 +12539,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCoarseSampleLocationNV *>( this );
     }
 
-    operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCoarseSampleLocationNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( pixelX, pixelY, sample );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CoarseSampleLocationNV const & ) const = default;
 #else
     bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13144,24 +12586,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>::value,
                             "CoarseSampleLocationNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelX );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelY );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.sample );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CoarseSampleOrderCustomNV
   {
     using NativeType = VkCoarseSampleOrderCustomNV;
@@ -13248,28 +12672,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( this );
     }
 
-    operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCoarseSampleOrderCustomNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default;
 #else
     bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) &&
-             ( sampleLocationCount == rhs.sampleLocationCount ) && ( pSampleLocations == rhs.pSampleLocations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13288,27 +12724,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>::value,
                             "CoarseSampleOrderCustomNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV, seed, coarseSampleOrderCustomNV.shadingRate );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleLocationCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV *, seed, coarseSampleOrderCustomNV.pSampleLocations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferAllocateInfo
   {
     using NativeType = VkCommandBufferAllocateInfo;
@@ -13371,28 +12786,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferAllocateInfo *>( this );
     }
 
-    operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferAllocateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::CommandPool const &,
+               VULKAN_HPP_NAMESPACE::CommandBufferLevel const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, commandPool, level, commandBufferCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferAllocateInfo const & ) const = default;
 #else
     bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) &&
-             ( level == rhs.level ) && ( commandBufferCount == rhs.commandBufferCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13417,26 +12845,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferAllocateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferAllocateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferAllocateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPool, seed, commandBufferAllocateInfo.commandPool );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferLevel, seed, commandBufferAllocateInfo.level );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferAllocateInfo.commandBufferCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferInheritanceInfo
   {
     using NativeType = VkCommandBufferInheritanceInfo;
@@ -13525,30 +12933,45 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceInfo *>( this );
     }
 
-    operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferInheritanceInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RenderPass const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Framebuffer const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::QueryControlFlags const &,
+               VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceInfo const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
-             ( subpass == rhs.subpass ) && ( framebuffer == rhs.framebuffer ) &&
-             ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) &&
-             ( pipelineStatistics == rhs.pipelineStatistics );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13577,30 +13000,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, commandBufferInheritanceInfo.renderPass );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceInfo.subpass );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, commandBufferInheritanceInfo.framebuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceInfo.occlusionQueryEnable );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryControlFlags, seed, commandBufferInheritanceInfo.queryFlags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, commandBufferInheritanceInfo.pipelineStatistics );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferBeginInfo
   {
     using NativeType = VkCommandBufferBeginInfo;
@@ -13653,28 +13052,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferBeginInfo *>( this );
     }
 
-    operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferBeginInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags const &,
+               const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pInheritanceInfo );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferBeginInfo const & ) const = default;
 #else
     bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pInheritanceInfo == rhs.pInheritanceInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13698,26 +13109,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferBeginInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferBeginInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferBeginInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags, seed, commandBufferBeginInfo.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo *, seed, commandBufferBeginInfo.pInheritanceInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferInheritanceConditionalRenderingInfoEXT
   {
     using NativeType = VkCommandBufferInheritanceConditionalRenderingInfoEXT;
@@ -13769,28 +13160,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>( this );
     }
 
-    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, conditionalRenderingEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( conditionalRenderingEnable == rhs.conditionalRenderingEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13815,27 +13215,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceConditionalRenderingInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const &
-                            commandBufferInheritanceConditionalRenderingInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferInheritanceRenderPassTransformInfoQCOM
   {
     using NativeType = VkCommandBufferInheritanceRenderPassTransformInfoQCOM;
@@ -13897,28 +13276,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>( this );
     }
 
-    operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+               VULKAN_HPP_NAMESPACE::Rect2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, transform, renderArea );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) &&
-             ( renderArea == rhs.renderArea );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -13945,29 +13336,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const &
-                            commandBufferInheritanceRenderPassTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR,
-                             seed,
-                             commandBufferInheritanceRenderPassTransformInfoQCOM.transform );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Rect2D, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferInheritanceRenderingInfoKHR
   {
     using NativeType = VkCommandBufferInheritanceRenderingInfoKHR;
@@ -14102,32 +13470,53 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferInheritanceRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR *>( this );
     }
 
-    operator VkCommandBufferInheritanceRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RenderingFlagsKHR const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Format * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       viewMask,
+                       colorAttachmentCount,
+                       pColorAttachmentFormats,
+                       depthAttachmentFormat,
+                       stencilAttachmentFormat,
+                       rasterizationSamples );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceRenderingInfoKHR const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
-             ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
-             ( depthAttachmentFormat == rhs.depthAttachmentFormat ) &&
-             ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) &&
-             ( rasterizationSamples == rhs.rasterizationSamples );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -14158,36 +13547,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceRenderingInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR const &
-                            commandBufferInheritanceRenderingInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderingInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceRenderingInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, commandBufferInheritanceRenderingInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.viewMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.colorAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Format *, seed, commandBufferInheritanceRenderingInfoKHR.pColorAttachmentFormats );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.depthAttachmentFormat );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.stencilAttachmentFormat );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, commandBufferInheritanceRenderingInfoKHR.rasterizationSamples );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct Viewport
   {
     using NativeType = VkViewport;
@@ -14258,28 +13617,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkViewport const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkViewport const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViewport *>( this );
     }
 
-    operator VkViewport &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkViewport &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkViewport *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<float const &, float const &, float const &, float const &, float const &, float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( x, y, width, height, minDepth, maxDepth );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Viewport const & ) const = default;
 #else
     bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) &&
-             ( minDepth == rhs.minDepth ) && ( maxDepth == rhs.maxDepth );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -14298,26 +13666,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Viewport>::value,
                             "Viewport is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Viewport>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.x );
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.y );
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.width );
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.height );
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.minDepth );
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.maxDepth );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferInheritanceViewportScissorInfoNV
   {
     using NativeType = VkCommandBufferInheritanceViewportScissorInfoNV;
@@ -14386,28 +13734,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV *>( this );
     }
 
-    operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Viewport * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) &&
-             ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -14434,29 +13795,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceViewportScissorInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const &
-                            commandBufferInheritanceViewportScissorInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceViewportScissorInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceViewportScissorInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Viewport *, seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandBufferSubmitInfoKHR
   {
     using NativeType = VkCommandBufferSubmitInfoKHR;
@@ -14508,28 +13846,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandBufferSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferSubmitInfoKHR *>( this );
     }
 
-    operator VkCommandBufferSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandBufferSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandBufferSubmitInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::CommandBuffer const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, commandBuffer, deviceMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferSubmitInfoKHR const & ) const = default;
 #else
     bool operator==( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) &&
-             ( deviceMask == rhs.deviceMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -14553,25 +13903,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferSubmitInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR const & commandBufferSubmitInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferSubmitInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferSubmitInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBuffer, seed, commandBufferSubmitInfoKHR.commandBuffer );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferSubmitInfoKHR.deviceMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CommandPoolCreateInfo
   {
     using NativeType = VkCommandPoolCreateInfo;
@@ -14623,28 +13954,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandPoolCreateInfo *>( this );
     }
 
-    operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCommandPoolCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, queueFamilyIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandPoolCreateInfo const & ) const = default;
 #else
     bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( queueFamilyIndex == rhs.queueFamilyIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -14667,25 +14010,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandPoolCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandPoolCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandPoolCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags, seed, commandPoolCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandPoolCreateInfo.queueFamilyIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SpecializationMapEntry
   {
     using NativeType = VkSpecializationMapEntry;
@@ -14733,27 +14057,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSpecializationMapEntry *>( this );
     }
 
-    operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSpecializationMapEntry *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, size_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( constantID, offset, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SpecializationMapEntry const & ) const = default;
 #else
     bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -14770,24 +14104,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>::value,
                             "SpecializationMapEntry is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.constantID );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.offset );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationMapEntry.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SpecializationInfo
   {
     using NativeType = VkSpecializationInfo;
@@ -14879,28 +14195,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSpecializationInfo *>( this );
     }
 
-    operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSpecializationInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SpecializationMapEntry * const &,
+               size_t const &,
+               const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( mapEntryCount, pMapEntries, dataSize, pData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SpecializationInfo const & ) const = default;
 #else
     bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) &&
-             ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -14917,26 +14245,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SpecializationInfo>::value,
                             "SpecializationInfo is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SpecializationInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationInfo.mapEntryCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SpecializationMapEntry *, seed, specializationInfo.pMapEntries );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationInfo.dataSize );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, specializationInfo.pData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineShaderStageCreateInfo
   {
     using NativeType = VkPipelineShaderStageCreateInfo;
@@ -15017,28 +14325,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineShaderStageCreateInfo *>( this );
     }
 
-    operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineShaderStageCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::ShaderStageFlagBits const &,
+               VULKAN_HPP_NAMESPACE::ShaderModule const &,
+               const char * const &,
+               const VULKAN_HPP_NAMESPACE::SpecializationInfo * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineShaderStageCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) &&
-             ( module == rhs.module ) && ( pName == rhs.pName ) && ( pSpecializationInfo == rhs.pSpecializationInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -15066,30 +14389,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineShaderStageCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineShaderStageCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags, seed, pipelineShaderStageCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits, seed, pipelineShaderStageCreateInfo.stage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModule, seed, pipelineShaderStageCreateInfo.module );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, pipelineShaderStageCreateInfo.pName );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SpecializationInfo *, seed, pipelineShaderStageCreateInfo.pSpecializationInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ComputePipelineCreateInfo
   {
     using NativeType = VkComputePipelineCreateInfo;
@@ -15169,29 +14468,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkComputePipelineCreateInfo *>( this );
     }
 
-    operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkComputePipelineCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const &,
+               VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+               VULKAN_HPP_NAMESPACE::Pipeline const &,
+               int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ComputePipelineCreateInfo const & ) const = default;
 #else
     bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) &&
-             ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) &&
-             ( basePipelineIndex == rhs.basePipelineIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -15218,29 +14531,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ComputePipelineCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, computePipelineCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, computePipelineCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, computePipelineCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo, seed, computePipelineCreateInfo.stage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, computePipelineCreateInfo.layout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, computePipelineCreateInfo.basePipelineHandle );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, computePipelineCreateInfo.basePipelineIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ConditionalRenderingBeginInfoEXT
   {
     using NativeType = VkConditionalRenderingBeginInfoEXT;
@@ -15304,28 +14594,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( this );
     }
 
-    operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, buffer, offset, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default;
 #else
     bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) &&
-             ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -15351,28 +14654,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ConditionalRenderingBeginInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, conditionalRenderingBeginInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, conditionalRenderingBeginInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, conditionalRenderingBeginInfoEXT.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, conditionalRenderingBeginInfoEXT.offset );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT, seed, conditionalRenderingBeginInfoEXT.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ConformanceVersion
   {
     using NativeType = VkConformanceVersion;
@@ -15429,27 +14710,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkConformanceVersion *>( this );
     }
 
-    operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkConformanceVersion *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint8_t const &, uint8_t const &, uint8_t const &, uint8_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( major, minor, subminor, patch );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ConformanceVersion const & ) const = default;
 #else
     bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -15467,25 +14758,6 @@ namespace VULKAN_HPP_NAMESPACE
                             "ConformanceVersion is not nothrow_move_constructible!" );
   using ConformanceVersionKHR = ConformanceVersion;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ConformanceVersion>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.major );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.minor );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.subminor );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.patch );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CooperativeMatrixPropertiesNV
   {
     using NativeType = VkCooperativeMatrixPropertiesNV;
@@ -15591,29 +14863,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCooperativeMatrixPropertiesNV *>( this );
     }
 
-    operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+               VULKAN_HPP_NAMESPACE::ScopeNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default;
 #else
     bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) &&
-             ( KSize == rhs.KSize ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) &&
-             ( DType == rhs.DType ) && ( scope == rhs.scope );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -15644,31 +14933,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CooperativeMatrixPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cooperativeMatrixPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, cooperativeMatrixPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.MSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.NSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.KSize );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.AType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.BType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.CType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.DType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ScopeNV, seed, cooperativeMatrixPropertiesNV.scope );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyAccelerationStructureInfoKHR
   {
     using NativeType = VkCopyAccelerationStructureInfoKHR;
@@ -15733,28 +14997,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( this );
     }
 
-    operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyAccelerationStructureInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+               VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, src, dst, mode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default;
 #else
     bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) &&
-             ( mode == rhs.mode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -15781,30 +15058,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyAccelerationStructureInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyAccelerationStructureInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyAccelerationStructureInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.src );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.dst );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR, seed, copyAccelerationStructureInfoKHR.mode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyAccelerationStructureToMemoryInfoKHR
   {
     using NativeType = VkCopyAccelerationStructureToMemoryInfoKHR;
@@ -15874,16 +15127,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( this );
     }
 
-    operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const &,
+               VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, src, dst, mode );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType            sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR;
     const void *                                   pNext = {};
@@ -16000,28 +15267,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyBufferInfo2KHR *>( this );
     }
 
-    operator VkCopyBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyBufferInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::BufferCopy2KHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyBufferInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) &&
-             ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -16046,27 +15327,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyBufferInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR const & copyBufferInfo2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.srcBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.dstBuffer );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferInfo2KHR.regionCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferCopy2KHR *, seed, copyBufferInfo2KHR.pRegions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyBufferToImageInfo2KHR
   {
     using NativeType = VkCopyBufferToImageInfo2KHR;
@@ -16171,29 +15431,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyBufferToImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyBufferToImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( this );
     }
 
-    operator VkCopyBufferToImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyBufferToImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyBufferToImageInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyBufferToImageInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) &&
-             ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) &&
-             ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -16220,29 +15494,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyBufferToImageInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR const & copyBufferToImageInfo2KHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferToImageInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferToImageInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferToImageInfo2KHR.srcBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyBufferToImageInfo2KHR.dstImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyBufferToImageInfo2KHR.dstImageLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferToImageInfo2KHR.regionCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyBufferToImageInfo2KHR.pRegions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyCommandTransformInfoQCOM
   {
     using NativeType = VkCopyCommandTransformInfoQCOM;
@@ -16288,27 +15539,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyCommandTransformInfoQCOM *>( this );
     }
 
-    operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyCommandTransformInfoQCOM *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, transform );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default;
 #else
     bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -16333,25 +15596,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyCommandTransformInfoQCOM;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyCommandTransformInfoQCOM.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyCommandTransformInfoQCOM.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, copyCommandTransformInfoQCOM.transform );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyDescriptorSet
   {
     using NativeType = VkCopyDescriptorSet;
@@ -16443,30 +15687,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyDescriptorSet *>( this );
     }
 
-    operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyDescriptorSet *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DescriptorSet const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DescriptorSet const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyDescriptorSet const & ) const = default;
 #else
     bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) &&
-             ( srcBinding == rhs.srcBinding ) && ( srcArrayElement == rhs.srcArrayElement ) &&
-             ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) &&
-             ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -16494,29 +15754,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyDescriptorSet;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyDescriptorSet.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyDescriptorSet.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.srcSet );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcBinding );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcArrayElement );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.dstSet );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstBinding );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstArrayElement );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.descriptorCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageCopy2KHR
   {
     using NativeType = VkImageCopy2KHR;
@@ -16595,29 +15832,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageCopy2KHR *>( this );
     }
 
-    operator VkImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageCopy2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageCopy2KHR const & ) const = default;
 #else
     bool operator==( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
-             ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) &&
-             ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -16643,27 +15894,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageCopy2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageCopy2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2KHR const & imageCopy2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCopy2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCopy2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.srcSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.srcOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.dstSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.dstOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy2KHR.extent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyImageInfo2KHR
   {
     using NativeType = VkCopyImageInfo2KHR;
@@ -16776,30 +16006,44 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyImageInfo2KHR *>( this );
     }
 
-    operator VkCopyImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyImageInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ImageCopy2KHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyImageInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
-             ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
-             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
-             ( pRegions == rhs.pRegions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -16826,28 +16070,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyImageInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR const & copyImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.srcImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.srcImageLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.dstImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.dstImageLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageInfo2KHR.regionCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageCopy2KHR *, seed, copyImageInfo2KHR.pRegions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyImageToBufferInfo2KHR
   {
     using NativeType = VkCopyImageToBufferInfo2KHR;
@@ -16952,29 +16174,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyImageToBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyImageToBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( this );
     }
 
-    operator VkCopyImageToBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyImageToBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyImageToBufferInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyImageToBufferInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
-             ( srcImageLayout == rhs.srcImageLayout ) && ( dstBuffer == rhs.dstBuffer ) &&
-             ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -17001,29 +16237,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyImageToBufferInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR const & copyImageToBufferInfo2KHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageToBufferInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageToBufferInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageToBufferInfo2KHR.srcImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageToBufferInfo2KHR.srcImageLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyImageToBufferInfo2KHR.dstBuffer );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageToBufferInfo2KHR.regionCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyImageToBufferInfo2KHR.pRegions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CopyMemoryToAccelerationStructureInfoKHR
   {
     using NativeType = VkCopyMemoryToAccelerationStructureInfoKHR;
@@ -17093,16 +16306,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( this );
     }
 
-    operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+               VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, src, dst, mode );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType               sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR;
     const void *                                      pNext = {};
@@ -17177,27 +16404,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( this );
     }
 
-    operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCuFunctionCreateInfoNVX *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::CuModuleNVX const &,
+               const char * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, module, pName );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CuFunctionCreateInfoNVX const & ) const = default;
 #else
     bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( pName == rhs.pName );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -17221,25 +16461,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CuFunctionCreateInfoNVX;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuFunctionCreateInfoNVX.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuFunctionCreateInfoNVX.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuModuleNVX, seed, cuFunctionCreateInfoNVX.module );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, cuFunctionCreateInfoNVX.pName );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CuLaunchInfoNVX
   {
     using NativeType = VkCuLaunchInfoNVX;
@@ -17416,31 +16637,63 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCuLaunchInfoNVX *>( this );
     }
 
-    operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCuLaunchInfoNVX *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::CuFunctionNVX const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               size_t const &,
+               const void * const * const &,
+               size_t const &,
+               const void * const * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       function,
+                       gridDimX,
+                       gridDimY,
+                       gridDimZ,
+                       blockDimX,
+                       blockDimY,
+                       blockDimZ,
+                       sharedMemBytes,
+                       paramCount,
+                       pParams,
+                       extraCount,
+                       pExtras );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CuLaunchInfoNVX const & ) const = default;
 #else
     bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) &&
-             ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && ( gridDimZ == rhs.gridDimZ ) &&
-             ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) &&
-             ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) &&
-             ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && ( pExtras == rhs.pExtras );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -17473,34 +16726,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CuLaunchInfoNVX;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuLaunchInfoNVX.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuLaunchInfoNVX.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuFunctionNVX, seed, cuLaunchInfoNVX.function );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimX );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimY );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimZ );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimX );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimY );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimZ );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.sharedMemBytes );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.paramCount );
-    VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pParams );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.extraCount );
-    VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pExtras );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct CuModuleCreateInfoNVX
   {
     using NativeType = VkCuModuleCreateInfoNVX;
@@ -17567,27 +16792,37 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCuModuleCreateInfoNVX *>( this );
     }
 
-    operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkCuModuleCreateInfoNVX *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, size_t const &, const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, dataSize, pData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CuModuleCreateInfoNVX const & ) const = default;
 #else
     bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -17610,25 +16845,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CuModuleCreateInfoNVX;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuModuleCreateInfoNVX.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pNext );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, cuModuleCreateInfoNVX.dataSize );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct D3D12FenceSubmitInfoKHR
   {
@@ -17730,31 +16946,47 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>( this );
     }
 
-    operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint64_t * const &,
+               uint32_t const &,
+               const uint64_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       waitSemaphoreValuesCount,
+                       pWaitSemaphoreValues,
+                       signalSemaphoreValuesCount,
+                       pSignalSemaphoreValues );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default;
 #  else
     bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) &&
-             ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) &&
-             ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) &&
-             ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -17779,28 +17011,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = D3D12FenceSubmitInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, d3D12FenceSubmitInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, d3D12FenceSubmitInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct DebugMarkerMarkerInfoEXT
@@ -17853,28 +17063,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( this );
     }
 
-    operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const char * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pMarkerName, color );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugMarkerMarkerInfoEXT const & ) const = default;
 #else
     bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pMarkerName == rhs.pMarkerName ) &&
-             ( color == rhs.color );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -17898,28 +17120,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugMarkerMarkerInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerMarkerInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerMarkerInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerMarkerInfoEXT.pMarkerName );
-    for ( size_t i = 0; i < 4; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( float, seed, debugMarkerMarkerInfoEXT.color[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugMarkerObjectNameInfoEXT
   {
     using NativeType = VkDebugMarkerObjectNameInfoEXT;
@@ -17981,28 +17181,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( this );
     }
 
-    operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT const &,
+               uint64_t const &,
+               const char * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, objectType, object, pObjectName );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugMarkerObjectNameInfoEXT const & ) const = default;
 #else
     bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
-             ( object == rhs.object ) && ( pObjectName == rhs.pObjectName );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -18029,27 +17242,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugMarkerObjectNameInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectNameInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectNameInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectNameInfoEXT.objectType );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectNameInfoEXT.object );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerObjectNameInfoEXT.pObjectName );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugMarkerObjectTagInfoEXT
   {
     using NativeType = VkDebugMarkerObjectTagInfoEXT;
@@ -18151,29 +17343,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( this );
     }
 
-    operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT const &,
+               uint64_t const &,
+               uint64_t const &,
+               size_t const &,
+               const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default;
 #else
     bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
-             ( object == rhs.object ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) &&
-             ( pTag == rhs.pTag );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -18202,29 +17408,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugMarkerObjectTagInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectTagInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectTagInfoEXT.objectType );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.object );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.tagName );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, debugMarkerObjectTagInfoEXT.tagSize );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pTag );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugReportCallbackCreateInfoEXT
   {
     using NativeType = VkDebugReportCallbackCreateInfoEXT;
@@ -18286,28 +17469,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( this );
     }
 
-    operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT const &,
+               PFN_vkDebugReportCallbackEXT const &,
+               void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pfnCallback, pUserData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugReportCallbackCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -18333,27 +17529,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugReportCallbackCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugReportCallbackCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugReportCallbackCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT, seed, debugReportCallbackCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( PFN_vkDebugReportCallbackEXT, seed, debugReportCallbackCreateInfoEXT.pfnCallback );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, debugReportCallbackCreateInfoEXT.pUserData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugUtilsLabelEXT
   {
     using NativeType = VkDebugUtilsLabelEXT;
@@ -18403,28 +17578,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsLabelEXT *>( this );
     }
 
-    operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugUtilsLabelEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const char * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pLabelName, color );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsLabelEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pLabelName == rhs.pLabelName ) &&
-             ( color == rhs.color );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -18447,28 +17634,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsLabelEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsLabelEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsLabelEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsLabelEXT.pLabelName );
-    for ( size_t i = 0; i < 4; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( float, seed, debugUtilsLabelEXT.color[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugUtilsObjectNameInfoEXT
   {
     using NativeType = VkDebugUtilsObjectNameInfoEXT;
@@ -18530,28 +17695,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( this );
     }
 
-    operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ObjectType const &,
+               uint64_t const &,
+               const char * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, objectType, objectHandle, pObjectName );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsObjectNameInfoEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
-             ( objectHandle == rhs.objectHandle ) && ( pObjectName == rhs.pObjectName );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -18577,26 +17755,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsObjectNameInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectNameInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectNameInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectNameInfoEXT.objectType );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectNameInfoEXT.objectHandle );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsObjectNameInfoEXT.pObjectName );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugUtilsMessengerCallbackDataEXT
   {
     using NativeType = VkDebugUtilsMessengerCallbackDataEXT;
@@ -18783,32 +17941,59 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( this );
     }
 
-    operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT const &,
+               const char * const &,
+               int32_t const &,
+               const char * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       pMessageIdName,
+                       messageIdNumber,
+                       pMessage,
+                       queueLabelCount,
+                       pQueueLabels,
+                       cmdBufLabelCount,
+                       pCmdBufLabels,
+                       objectCount,
+                       pObjects );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsMessengerCallbackDataEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pMessageIdName == rhs.pMessageIdName ) && ( messageIdNumber == rhs.messageIdNumber ) &&
-             ( pMessage == rhs.pMessage ) && ( queueLabelCount == rhs.queueLabelCount ) &&
-             ( pQueueLabels == rhs.pQueueLabels ) && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) &&
-             ( pCmdBufLabels == rhs.pCmdBufLabels ) && ( objectCount == rhs.objectCount ) &&
-             ( pObjects == rhs.pObjects );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -18841,37 +18026,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsMessengerCallbackDataEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const &
-                            debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCallbackDataEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCallbackDataEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT, seed, debugUtilsMessengerCallbackDataEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessageIdName );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessage );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.objectCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT *, seed, debugUtilsMessengerCallbackDataEXT.pObjects );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugUtilsMessengerCreateInfoEXT
   {
     using NativeType = VkDebugUtilsMessengerCreateInfoEXT;
@@ -18952,29 +18106,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( this );
     }
 
-    operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT const &,
+               PFN_vkDebugUtilsMessengerCallbackEXT const &,
+               void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsMessengerCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( messageSeverity == rhs.messageSeverity ) && ( messageType == rhs.messageType ) &&
-             ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19002,33 +18170,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsMessengerCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageSeverity );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageType );
-    VULKAN_HPP_HASH_COMBINE(
-      PFN_vkDebugUtilsMessengerCallbackEXT, seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, debugUtilsMessengerCreateInfoEXT.pUserData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DebugUtilsObjectTagInfoEXT
   {
     using NativeType = VkDebugUtilsObjectTagInfoEXT;
@@ -19130,29 +18271,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( this );
     }
 
-    operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ObjectType const &,
+               uint64_t const &,
+               uint64_t const &,
+               size_t const &,
+               const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
-             ( objectHandle == rhs.objectHandle ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) &&
-             ( pTag == rhs.pTag );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19179,28 +18334,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsObjectTagInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectTagInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectTagInfoEXT.objectType );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.objectHandle );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.tagName );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, debugUtilsObjectTagInfoEXT.tagSize );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pTag );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DedicatedAllocationBufferCreateInfoNV
   {
     using NativeType = VkDedicatedAllocationBufferCreateInfoNV;
@@ -19248,27 +18381,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>( this );
     }
 
-    operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, dedicatedAllocation );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default;
 #else
     bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19292,25 +18435,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DedicatedAllocationBufferCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const &
-                            dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationBufferCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationBufferCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DedicatedAllocationImageCreateInfoNV
   {
     using NativeType = VkDedicatedAllocationImageCreateInfoNV;
@@ -19358,27 +18482,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>( this );
     }
 
-    operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, dedicatedAllocation );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default;
 #else
     bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19402,25 +18536,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DedicatedAllocationImageCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const &
-                            dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationImageCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationImageCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DedicatedAllocationMemoryAllocateInfoNV
   {
     using NativeType = VkDedicatedAllocationMemoryAllocateInfoNV;
@@ -19479,27 +18594,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>( this );
     }
 
-    operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, image, buffer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default;
 #else
     bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19525,25 +18653,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DedicatedAllocationMemoryAllocateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const &
-                            dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationMemoryAllocateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationMemoryAllocateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, dedicatedAllocationMemoryAllocateInfoNV.image );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, dedicatedAllocationMemoryAllocateInfoNV.buffer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryBarrier2KHR
   {
     using NativeType = VkMemoryBarrier2KHR;
@@ -19614,29 +18723,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryBarrier2KHR *>( this );
     }
 
-    operator VkMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryBarrier2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryBarrier2KHR const & ) const = default;
 #else
     bool operator==( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
-             ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
-             ( dstAccessMask == rhs.dstAccessMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19661,26 +18783,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryBarrier2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR const & memoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.srcStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.dstStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.dstAccessMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageSubresourceRange
   {
     using NativeType = VkImageSubresourceRange;
@@ -19746,29 +18848,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSubresourceRange *>( this );
     }
 
-    operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageSubresourceRange *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSubresourceRange const & ) const = default;
 #else
     bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) &&
-             ( levelCount == rhs.levelCount ) && ( baseArrayLayer == rhs.baseArrayLayer ) &&
-             ( layerCount == rhs.layerCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19786,26 +18900,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>::value,
                             "ImageSubresourceRange is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceRange.aspectMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseMipLevel );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.levelCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseArrayLayer );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.layerCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageMemoryBarrier2KHR
   {
     using NativeType = VkImageMemoryBarrier2KHR;
@@ -19929,32 +19023,59 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageMemoryBarrier2KHR *>( this );
     }
 
-    operator VkImageMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageMemoryBarrier2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       srcStageMask,
+                       srcAccessMask,
+                       dstStageMask,
+                       dstAccessMask,
+                       oldLayout,
+                       newLayout,
+                       srcQueueFamilyIndex,
+                       dstQueueFamilyIndex,
+                       image,
+                       subresourceRange );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageMemoryBarrier2KHR const & ) const = default;
 #else
     bool operator==( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
-             ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
-             ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) &&
-             ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
-             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) &&
-             ( subresourceRange == rhs.subresourceRange );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -19986,34 +19107,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageMemoryBarrier2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR const & imageMemoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.srcStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.dstStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.dstAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.oldLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.newLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.srcQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.dstQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier2KHR.image );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier2KHR.subresourceRange );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DependencyInfoKHR
   {
     using NativeType = VkDependencyInfoKHR;
@@ -20163,32 +19256,53 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDependencyInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDependencyInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDependencyInfoKHR *>( this );
     }
 
-    operator VkDependencyInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDependencyInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDependencyInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DependencyFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       dependencyFlags,
+                       memoryBarrierCount,
+                       pMemoryBarriers,
+                       bufferMemoryBarrierCount,
+                       pBufferMemoryBarriers,
+                       imageMemoryBarrierCount,
+                       pImageMemoryBarriers );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DependencyInfoKHR const & ) const = default;
 #else
     bool operator==( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) &&
-             ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) &&
-             ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) &&
-             ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) &&
-             ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) &&
-             ( pImageMemoryBarriers == rhs.pImageMemoryBarriers );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -20216,31 +19330,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DependencyInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DependencyInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfoKHR const & dependencyInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dependencyInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, dependencyInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, dependencyInfoKHR.dependencyFlags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.memoryBarrierCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR *, seed, dependencyInfoKHR.pMemoryBarriers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.bufferMemoryBarrierCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR *, seed, dependencyInfoKHR.pBufferMemoryBarriers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.imageMemoryBarrierCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR *, seed, dependencyInfoKHR.pImageMemoryBarriers );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorBufferInfo
   {
     using NativeType = VkDescriptorBufferInfo;
@@ -20291,27 +19380,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorBufferInfo *>( this );
     }
 
-    operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorBufferInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( buffer, offset, range );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorBufferInfo const & ) const = default;
 #else
     bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -20327,24 +19428,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>::value,
                             "DescriptorBufferInfo is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, descriptorBufferInfo.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.range );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorImageInfo
   {
     using NativeType = VkDescriptorImageInfo;
@@ -20397,27 +19480,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorImageInfo *>( this );
     }
 
-    operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorImageInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Sampler const &,
+               VULKAN_HPP_NAMESPACE::ImageView const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sampler, imageView, imageLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorImageInfo const & ) const = default;
 #else
     bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -20433,24 +19528,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>::value,
                             "DescriptorImageInfo is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, descriptorImageInfo.sampler );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, descriptorImageInfo.imageView );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, descriptorImageInfo.imageLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorPoolSize
   {
     using NativeType = VkDescriptorPoolSize;
@@ -20493,27 +19570,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorPoolSize *>( this );
     }
 
-    operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorPoolSize *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DescriptorType const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( type, descriptorCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorPoolSize const & ) const = default;
 #else
     bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -20528,23 +19615,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>::value,
                             "DescriptorPoolSize is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorPoolSize.type );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolSize.descriptorCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorPoolCreateInfo
   {
     using NativeType = VkDescriptorPoolCreateInfo;
@@ -20636,28 +19706,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorPoolCreateInfo *>( this );
     }
 
-    operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorPoolCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorPoolSize * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorPoolCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) &&
-             ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -20683,28 +19767,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorPoolCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags, seed, descriptorPoolCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.maxSets );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.poolSizeCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DescriptorPoolSize *, seed, descriptorPoolCreateInfo.pPoolSizes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorPoolInlineUniformBlockCreateInfoEXT
   {
     using NativeType = VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
@@ -20755,28 +19817,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>( this );
     }
 
-    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxInlineUniformBlockBindings );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -20801,26 +19872,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorPoolInlineUniformBlockCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT const &
-                            descriptorPoolInlineUniformBlockCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.maxInlineUniformBlockBindings );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorSetAllocateInfo
   {
     using NativeType = VkDescriptorSetAllocateInfo;
@@ -20905,28 +19956,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetAllocateInfo *>( this );
     }
 
-    operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorSetAllocateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DescriptorPool const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetAllocateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) &&
-             ( descriptorSetCount == rhs.descriptorSetCount ) && ( pSetLayouts == rhs.pSetLayouts );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -20951,27 +20015,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorSetAllocateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetAllocateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetAllocateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPool, seed, descriptorSetAllocateInfo.descriptorPool );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetAllocateInfo.descriptorSetCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, descriptorSetAllocateInfo.pSetLayouts );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorSetLayoutBinding
   {
     using NativeType = VkDescriptorSetLayoutBinding;
@@ -21067,29 +20110,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutBinding *>( this );
     }
 
-    operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorSetLayoutBinding *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DescriptorType const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+               const VULKAN_HPP_NAMESPACE::Sampler * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutBinding const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) &&
-             ( descriptorCount == rhs.descriptorCount ) && ( stageFlags == rhs.stageFlags ) &&
-             ( pImmutableSamplers == rhs.pImmutableSamplers );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -21108,27 +20163,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>::value,
                             "DescriptorSetLayoutBinding is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.binding );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorSetLayoutBinding.descriptorType );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.descriptorCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, descriptorSetLayoutBinding.stageFlags );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Sampler *, seed, descriptorSetLayoutBinding.pImmutableSamplers );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorSetLayoutBindingFlagsCreateInfo
   {
     using NativeType = VkDescriptorSetLayoutBindingFlagsCreateInfo;
@@ -21207,28 +20241,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo *>( this );
     }
 
-    operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, bindingCount, pBindingFlags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) &&
-             ( pBindingFlags == rhs.pBindingFlags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -21255,28 +20301,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const &
-                            descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutBindingFlagsCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags *,
-                             seed,
-                             descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorSetLayoutCreateInfo
   {
     using NativeType = VkDescriptorSetLayoutCreateInfo;
@@ -21360,28 +20384,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( this );
     }
 
-    operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, bindingCount, pBindings );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( bindingCount == rhs.bindingCount ) && ( pBindings == rhs.pBindings );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -21407,28 +20444,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorSetLayoutCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags, seed, descriptorSetLayoutCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutCreateInfo.bindingCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding *, seed, descriptorSetLayoutCreateInfo.pBindings );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorSetLayoutSupport
   {
     using NativeType = VkDescriptorSetLayoutSupport;
@@ -21457,27 +20472,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutSupport *>( this );
     }
 
-    operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorSetLayoutSupport *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, supported );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutSupport const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -21501,24 +20526,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutSupport.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetLayoutSupport.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, descriptorSetLayoutSupport.supported );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorSetVariableDescriptorCountAllocateInfo
   {
     using NativeType = VkDescriptorSetVariableDescriptorCountAllocateInfo;
@@ -21596,28 +20603,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo *>( this );
     }
 
-    operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) &&
-             ( pDescriptorCounts == rhs.pDescriptorCounts );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -21644,27 +20663,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const &
-                            descriptorSetVariableDescriptorCountAllocateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountAllocateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const uint32_t *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorSetVariableDescriptorCountLayoutSupport
   {
     using NativeType = VkDescriptorSetVariableDescriptorCountLayoutSupport;
@@ -21700,28 +20698,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport *>( this );
     }
 
-    operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxVariableDescriptorCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default;
 #else
     bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -21747,26 +20754,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const &
-                            descriptorSetVariableDescriptorCountLayoutSupport ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountLayoutSupport.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorUpdateTemplateEntry
   {
     using NativeType = VkDescriptorUpdateTemplateEntry;
@@ -21845,29 +20832,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry *>( this );
     }
 
-    operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorUpdateTemplateEntry *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DescriptorType const &,
+               size_t const &,
+               size_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default;
 #else
     bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) &&
-             ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) &&
-             ( offset == rhs.offset ) && ( stride == rhs.stride );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -21889,27 +20889,6 @@ namespace VULKAN_HPP_NAMESPACE
     "DescriptorUpdateTemplateEntry is not nothrow_move_constructible!" );
   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstBinding );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstArrayElement );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.descriptorCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorUpdateTemplateEntry.descriptorType );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.offset );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.stride );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DescriptorUpdateTemplateCreateInfo
   {
     using NativeType = VkDescriptorUpdateTemplateCreateInfo;
@@ -22053,31 +21032,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( this );
     }
 
-    operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry * const &,
+               VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType const &,
+               VULKAN_HPP_NAMESPACE::DescriptorSetLayout const &,
+               VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+               VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       descriptorUpdateEntryCount,
+                       pDescriptorUpdateEntries,
+                       templateType,
+                       descriptorSetLayout,
+                       pipelineBindPoint,
+                       pipelineLayout,
+                       set );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) &&
-             ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) && ( templateType == rhs.templateType ) &&
-             ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
-             ( pipelineLayout == rhs.pipelineLayout ) && ( set == rhs.set );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -22110,38 +21113,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &
-                            descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorUpdateTemplateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorUpdateTemplateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags, seed, descriptorUpdateTemplateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry *,
-                             seed,
-                             descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType, seed, descriptorUpdateTemplateCreateInfo.templateType );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DescriptorSetLayout, seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineLayout, seed, descriptorUpdateTemplateCreateInfo.pipelineLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.set );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceBufferMemoryRequirementsKHR
   {
     using NativeType = VkDeviceBufferMemoryRequirementsKHR;
@@ -22188,27 +21159,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceBufferMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceBufferMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceBufferMemoryRequirementsKHR *>( this );
     }
 
-    operator VkDeviceBufferMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceBufferMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceBufferMemoryRequirementsKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const VULKAN_HPP_NAMESPACE::BufferCreateInfo * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pCreateInfo );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceBufferMemoryRequirementsKHR const & ) const = default;
 #else
     bool operator==( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -22232,25 +21215,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceBufferMemoryRequirementsKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR const &
-                            deviceBufferMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceBufferMemoryRequirementsKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceBufferMemoryRequirementsKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::BufferCreateInfo *, seed, deviceBufferMemoryRequirementsKHR.pCreateInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceQueueCreateInfo
   {
     using NativeType = VkDeviceQueueCreateInfo;
@@ -22340,29 +21304,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceQueueCreateInfo *>( this );
     }
 
-    operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceQueueCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags const &,
+               uint32_t const &,
+               uint32_t const &,
+               const float * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceQueueCreateInfo const & ) const = default;
 #else
     bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueCount == rhs.queueCount ) &&
-             ( pQueuePriorities == rhs.pQueuePriorities );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -22387,27 +21364,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceQueueCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueCount );
-    VULKAN_HPP_HASH_COMBINE( const float *, seed, deviceQueueCreateInfo.pQueuePriorities );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFeatures
   {
     using NativeType = VkPhysicalDeviceFeatures;
@@ -22928,66 +21884,145 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( robustBufferAccess,
+                       fullDrawIndexUint32,
+                       imageCubeArray,
+                       independentBlend,
+                       geometryShader,
+                       tessellationShader,
+                       sampleRateShading,
+                       dualSrcBlend,
+                       logicOp,
+                       multiDrawIndirect,
+                       drawIndirectFirstInstance,
+                       depthClamp,
+                       depthBiasClamp,
+                       fillModeNonSolid,
+                       depthBounds,
+                       wideLines,
+                       largePoints,
+                       alphaToOne,
+                       multiViewport,
+                       samplerAnisotropy,
+                       textureCompressionETC2,
+                       textureCompressionASTC_LDR,
+                       textureCompressionBC,
+                       occlusionQueryPrecise,
+                       pipelineStatisticsQuery,
+                       vertexPipelineStoresAndAtomics,
+                       fragmentStoresAndAtomics,
+                       shaderTessellationAndGeometryPointSize,
+                       shaderImageGatherExtended,
+                       shaderStorageImageExtendedFormats,
+                       shaderStorageImageMultisample,
+                       shaderStorageImageReadWithoutFormat,
+                       shaderStorageImageWriteWithoutFormat,
+                       shaderUniformBufferArrayDynamicIndexing,
+                       shaderSampledImageArrayDynamicIndexing,
+                       shaderStorageBufferArrayDynamicIndexing,
+                       shaderStorageImageArrayDynamicIndexing,
+                       shaderClipDistance,
+                       shaderCullDistance,
+                       shaderFloat64,
+                       shaderInt64,
+                       shaderInt16,
+                       shaderResourceResidency,
+                       shaderResourceMinLod,
+                       sparseBinding,
+                       sparseResidencyBuffer,
+                       sparseResidencyImage2D,
+                       sparseResidencyImage3D,
+                       sparseResidency2Samples,
+                       sparseResidency4Samples,
+                       sparseResidency8Samples,
+                       sparseResidency16Samples,
+                       sparseResidencyAliased,
+                       variableMultisampleRate,
+                       inheritedQueries );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( robustBufferAccess == rhs.robustBufferAccess ) && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) &&
-             ( imageCubeArray == rhs.imageCubeArray ) && ( independentBlend == rhs.independentBlend ) &&
-             ( geometryShader == rhs.geometryShader ) && ( tessellationShader == rhs.tessellationShader ) &&
-             ( sampleRateShading == rhs.sampleRateShading ) && ( dualSrcBlend == rhs.dualSrcBlend ) &&
-             ( logicOp == rhs.logicOp ) && ( multiDrawIndirect == rhs.multiDrawIndirect ) &&
-             ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) && ( depthClamp == rhs.depthClamp ) &&
-             ( depthBiasClamp == rhs.depthBiasClamp ) && ( fillModeNonSolid == rhs.fillModeNonSolid ) &&
-             ( depthBounds == rhs.depthBounds ) && ( wideLines == rhs.wideLines ) &&
-             ( largePoints == rhs.largePoints ) && ( alphaToOne == rhs.alphaToOne ) &&
-             ( multiViewport == rhs.multiViewport ) && ( samplerAnisotropy == rhs.samplerAnisotropy ) &&
-             ( textureCompressionETC2 == rhs.textureCompressionETC2 ) &&
-             ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) &&
-             ( textureCompressionBC == rhs.textureCompressionBC ) &&
-             ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) &&
-             ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) &&
-             ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) &&
-             ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) &&
-             ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) &&
-             ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) &&
-             ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) &&
-             ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) &&
-             ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) &&
-             ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) &&
-             ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) &&
-             ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) &&
-             ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) &&
-             ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) &&
-             ( shaderClipDistance == rhs.shaderClipDistance ) && ( shaderCullDistance == rhs.shaderCullDistance ) &&
-             ( shaderFloat64 == rhs.shaderFloat64 ) && ( shaderInt64 == rhs.shaderInt64 ) &&
-             ( shaderInt16 == rhs.shaderInt16 ) && ( shaderResourceResidency == rhs.shaderResourceResidency ) &&
-             ( shaderResourceMinLod == rhs.shaderResourceMinLod ) && ( sparseBinding == rhs.sparseBinding ) &&
-             ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) &&
-             ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) &&
-             ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) &&
-             ( sparseResidency2Samples == rhs.sparseResidency2Samples ) &&
-             ( sparseResidency4Samples == rhs.sparseResidency4Samples ) &&
-             ( sparseResidency8Samples == rhs.sparseResidency8Samples ) &&
-             ( sparseResidency16Samples == rhs.sparseResidency16Samples ) &&
-             ( sparseResidencyAliased == rhs.sparseResidencyAliased ) &&
-             ( variableMultisampleRate == rhs.variableMultisampleRate ) && ( inheritedQueries == rhs.inheritedQueries );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -23056,85 +22091,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>::value,
                             "PhysicalDeviceFeatures is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.robustBufferAccess );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fullDrawIndexUint32 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.imageCubeArray );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.independentBlend );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.geometryShader );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.tessellationShader );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sampleRateShading );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.dualSrcBlend );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.logicOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiDrawIndirect );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.drawIndirectFirstInstance );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthClamp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBiasClamp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fillModeNonSolid );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBounds );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.wideLines );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.largePoints );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.alphaToOne );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiViewport );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.samplerAnisotropy );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionETC2 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionASTC_LDR );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionBC );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.occlusionQueryPrecise );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.pipelineStatisticsQuery );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fragmentStoresAndAtomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderImageGatherExtended );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageMultisample );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderClipDistance );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderCullDistance );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderFloat64 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt64 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt16 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceResidency );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceMinLod );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseBinding );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage2D );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage3D );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency2Samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency4Samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency8Samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency16Samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyAliased );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.variableMultisampleRate );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.inheritedQueries );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceCreateInfo
   {
     using NativeType = VkDeviceCreateInfo;
@@ -23291,31 +22247,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceCreateInfo *>( this );
     }
 
-    operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo * const &,
+               uint32_t const &,
+               const char * const * const &,
+               uint32_t const &,
+               const char * const * const &,
+               const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       queueCreateInfoCount,
+                       pQueueCreateInfos,
+                       enabledLayerCount,
+                       ppEnabledLayerNames,
+                       enabledExtensionCount,
+                       ppEnabledExtensionNames,
+                       pEnabledFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceCreateInfo const & ) const = default;
 #else
     bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( queueCreateInfoCount == rhs.queueCreateInfoCount ) && ( pQueueCreateInfos == rhs.pQueueCreateInfos ) &&
-             ( enabledLayerCount == rhs.enabledLayerCount ) && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) &&
-             ( enabledExtensionCount == rhs.enabledExtensionCount ) &&
-             ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ) && ( pEnabledFeatures == rhs.pEnabledFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -23344,32 +22324,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceCreateFlags, seed, deviceCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.queueCreateInfoCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo *, seed, deviceCreateInfo.pQueueCreateInfos );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledLayerCount );
-    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledLayerNames );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledExtensionCount );
-    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledExtensionNames );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures *, seed, deviceCreateInfo.pEnabledFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceDeviceMemoryReportCreateInfoEXT
   {
     using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT;
@@ -23436,28 +22390,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>( this );
     }
 
-    operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT const &,
+               PFN_vkDeviceMemoryReportCallbackEXT const &,
+               void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pfnUserCallback, pUserData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceDeviceMemoryReportCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -23483,28 +22450,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceDeviceMemoryReportCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const &
-                            deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDeviceMemoryReportCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      PFN_vkDeviceMemoryReportCallbackEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceDiagnosticsConfigCreateInfoNV
   {
     using NativeType = VkDeviceDiagnosticsConfigCreateInfoNV;
@@ -23551,27 +22496,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV *>( this );
     }
 
-    operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default;
 #else
     bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -23595,25 +22552,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceDiagnosticsConfigCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const &
-                            deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDiagnosticsConfigCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDiagnosticsConfigCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV, seed, deviceDiagnosticsConfigCreateInfoNV.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceEventInfoEXT
   {
     using NativeType = VkDeviceEventInfoEXT;
@@ -23658,27 +22596,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceEventInfoEXT *>( this );
     }
 
-    operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceEventInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceEvent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceEventInfoEXT const & ) const = default;
 #else
     bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -23700,24 +22650,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceEventInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceEventInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceEventInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT, seed, deviceEventInfoEXT.deviceEvent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupBindSparseInfo
   {
     using NativeType = VkDeviceGroupBindSparseInfo;
@@ -23770,28 +22702,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupBindSparseInfo *>( this );
     }
 
-    operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupBindSparseInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) &&
-             ( memoryDeviceIndex == rhs.memoryDeviceIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -23816,25 +22757,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupBindSparseInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupBindSparseInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.resourceDeviceIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.memoryDeviceIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupCommandBufferBeginInfo
   {
     using NativeType = VkDeviceGroupCommandBufferBeginInfo;
@@ -23880,27 +22802,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>( this );
     }
 
-    operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -23925,24 +22857,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const &
-                            deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupCommandBufferBeginInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupCommandBufferBeginInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupCommandBufferBeginInfo.deviceMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupDeviceCreateInfo
   {
     using NativeType = VkDeviceGroupDeviceCreateInfo;
@@ -24016,28 +22930,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>( this );
     }
 
-    operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PhysicalDevice * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
-             ( pPhysicalDevices == rhs.pPhysicalDevices );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -24063,26 +22989,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupDeviceCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupDeviceCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupDeviceCreateInfo.physicalDeviceCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PhysicalDevice *, seed, deviceGroupDeviceCreateInfo.pPhysicalDevices );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupPresentCapabilitiesKHR
   {
     using NativeType = VkDeviceGroupPresentCapabilitiesKHR;
@@ -24116,28 +23022,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR *>( this );
     }
 
-    operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, VK_MAX_DEVICE_GROUP_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, presentMask, modes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) &&
-             ( modes == rhs.modes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -24162,29 +23080,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceGroupPresentCapabilitiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const &
-                            deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentCapabilitiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, deviceGroupPresentCapabilitiesKHR.pNext );
-    for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupPresentCapabilitiesKHR.modes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupPresentInfoKHR
   {
     using NativeType = VkDeviceGroupPresentInfoKHR;
@@ -24268,28 +23163,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>( this );
     }
 
-    operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupPresentInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default;
 #else
     bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
-             ( pDeviceMasks == rhs.pDeviceMasks ) && ( mode == rhs.mode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -24315,27 +23223,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceGroupPresentInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupPresentInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentInfoKHR.swapchainCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupPresentInfoKHR.pDeviceMasks );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR, seed, deviceGroupPresentInfoKHR.mode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupRenderPassBeginInfo
   {
     using NativeType = VkDeviceGroupRenderPassBeginInfo;
@@ -24419,28 +23306,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>( this );
     }
 
-    operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) &&
-             ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -24467,27 +23367,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupRenderPassBeginInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupRenderPassBeginInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Rect2D *, seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupSubmitInfo
   {
     using NativeType = VkDeviceGroupSubmitInfo;
@@ -24623,32 +23502,51 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupSubmitInfo *>( this );
     }
 
-    operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupSubmitInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       waitSemaphoreCount,
+                       pWaitSemaphoreDeviceIndices,
+                       commandBufferCount,
+                       pCommandBufferDeviceMasks,
+                       signalSemaphoreCount,
+                       pSignalSemaphoreDeviceIndices );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupSubmitInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
-             ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) &&
-             ( commandBufferCount == rhs.commandBufferCount ) &&
-             ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) &&
-             ( signalSemaphoreCount == rhs.signalSemaphoreCount ) &&
-             ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -24676,29 +23574,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSubmitInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSubmitInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.waitSemaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.commandBufferCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.signalSemaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceGroupSwapchainCreateInfoKHR
   {
     using NativeType = VkDeviceGroupSwapchainCreateInfoKHR;
@@ -24744,27 +23619,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>( this );
     }
 
-    operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, modes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default;
 #else
     bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -24788,25 +23675,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceGroupSwapchainCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const &
-                            deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSwapchainCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSwapchainCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupSwapchainCreateInfoKHR.modes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageCreateInfo
   {
     using NativeType = VkImageCreateInfo;
@@ -24994,32 +23862,65 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageCreateInfo *>( this );
     }
 
-    operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::ImageType const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::ImageTiling const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+               VULKAN_HPP_NAMESPACE::SharingMode const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       imageType,
+                       format,
+                       extent,
+                       mipLevels,
+                       arrayLayers,
+                       samples,
+                       tiling,
+                       usage,
+                       sharingMode,
+                       queueFamilyIndexCount,
+                       pQueueFamilyIndices,
+                       initialLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageCreateInfo const & ) const = default;
 #else
     bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( imageType == rhs.imageType ) && ( format == rhs.format ) && ( extent == rhs.extent ) &&
-             ( mipLevels == rhs.mipLevels ) && ( arrayLayers == rhs.arrayLayers ) && ( samples == rhs.samples ) &&
-             ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) &&
-             ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
-             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( initialLayout == rhs.initialLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25053,35 +23954,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, imageCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, imageCreateInfo.imageType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageCreateInfo.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCreateInfo.extent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.mipLevels );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.arrayLayers );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, imageCreateInfo.samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, imageCreateInfo.tiling );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageCreateInfo.usage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, imageCreateInfo.sharingMode );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.queueFamilyIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, imageCreateInfo.pQueueFamilyIndices );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageCreateInfo.initialLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceImageMemoryRequirementsKHR
   {
     using NativeType = VkDeviceImageMemoryRequirementsKHR;
@@ -25137,28 +24009,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceImageMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceImageMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceImageMemoryRequirementsKHR *>( this );
     }
 
-    operator VkDeviceImageMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceImageMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceImageMemoryRequirementsKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const VULKAN_HPP_NAMESPACE::ImageCreateInfo * const &,
+               VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pCreateInfo, planeAspect );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceImageMemoryRequirementsKHR const & ) const = default;
 #else
     bool operator==( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) &&
-             ( planeAspect == rhs.planeAspect );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25183,28 +24067,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceImageMemoryRequirementsKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR const & deviceImageMemoryRequirementsKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceImageMemoryRequirementsKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceImageMemoryRequirementsKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::ImageCreateInfo *, seed, deviceImageMemoryRequirementsKHR.pCreateInfo );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, deviceImageMemoryRequirementsKHR.planeAspect );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceMemoryOpaqueCaptureAddressInfo
   {
     using NativeType = VkDeviceMemoryOpaqueCaptureAddressInfo;
@@ -25252,27 +24114,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( this );
     }
 
-    operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memory );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default;
 #else
     bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25297,24 +24171,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const &
-                            deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOpaqueCaptureAddressInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOpaqueCaptureAddressInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, deviceMemoryOpaqueCaptureAddressInfo.memory );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceMemoryOverallocationCreateInfoAMD
   {
     using NativeType = VkDeviceMemoryOverallocationCreateInfoAMD;
@@ -25365,28 +24221,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>( this );
     }
 
-    operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, overallocationBehavior );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default;
 #else
     bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( overallocationBehavior == rhs.overallocationBehavior );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25412,26 +24279,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceMemoryOverallocationCreateInfoAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const &
-                            deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOverallocationCreateInfoAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOverallocationCreateInfoAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD,
-                             seed,
-                             deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceMemoryReportCallbackDataEXT
   {
     using NativeType = VkDeviceMemoryReportCallbackDataEXT;
@@ -25476,29 +24323,45 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT *>( this );
     }
 
-    operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::ObjectType const &,
+               uint64_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default;
 #else
     bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) &&
-             ( memoryObjectId == rhs.memoryObjectId ) && ( size == rhs.size ) && ( objectType == rhs.objectType ) &&
-             ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25529,32 +24392,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceMemoryReportCallbackDataEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const &
-                            deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryReportCallbackDataEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, deviceMemoryReportCallbackDataEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceMemoryReportCallbackDataEXT.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT, seed, deviceMemoryReportCallbackDataEXT.type );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.memoryObjectId );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, deviceMemoryReportCallbackDataEXT.size );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, deviceMemoryReportCallbackDataEXT.objectType );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.objectHandle );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceMemoryReportCallbackDataEXT.heapIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DevicePrivateDataCreateInfoEXT
   {
     using NativeType = VkDevicePrivateDataCreateInfoEXT;
@@ -25600,28 +24437,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDevicePrivateDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDevicePrivateDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT *>( this );
     }
 
-    operator VkDevicePrivateDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDevicePrivateDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDevicePrivateDataCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, privateDataSlotRequestCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DevicePrivateDataCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25645,24 +24491,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DevicePrivateDataCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT const & devicePrivateDataCreateInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, devicePrivateDataCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, devicePrivateDataCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, devicePrivateDataCreateInfoEXT.privateDataSlotRequestCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceQueueGlobalPriorityCreateInfoEXT
   {
     using NativeType = VkDeviceQueueGlobalPriorityCreateInfoEXT;
@@ -25712,27 +24540,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceQueueGlobalPriorityCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceQueueGlobalPriorityCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT *>( this );
     }
 
-    operator VkDeviceQueueGlobalPriorityCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceQueueGlobalPriorityCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, globalPriority );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25757,25 +24597,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceQueueGlobalPriorityCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT const &
-                            deviceQueueGlobalPriorityCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueGlobalPriorityCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueGlobalPriorityCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, deviceQueueGlobalPriorityCreateInfoEXT.globalPriority );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DeviceQueueInfo2
   {
     using NativeType = VkDeviceQueueInfo2;
@@ -25834,28 +24655,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceQueueInfo2 *>( this );
     }
 
-    operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDeviceQueueInfo2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceQueueInfo2 const & ) const = default;
 #else
     bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueIndex == rhs.queueIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -25879,25 +24713,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceQueueInfo2;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueInfo2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueInfo2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueInfo2.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
   struct DirectFBSurfaceCreateInfoEXT
   {
@@ -25958,28 +24773,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( this );
     }
 
-    operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT const &,
+               IDirectFB * const &,
+               IDirectFBSurface * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, dfb, surface );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) &&
-             ( surface == rhs.surface );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -26004,28 +24832,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = DirectFBSurfaceCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, directFBSurfaceCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, directFBSurfaceCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT, seed, directFBSurfaceCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( IDirectFB *, seed, directFBSurfaceCreateInfoEXT.dfb );
-    VULKAN_HPP_HASH_COMBINE( IDirectFBSurface *, seed, directFBSurfaceCreateInfoEXT.surface );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
 
   struct DispatchIndirectCommand
@@ -26075,27 +24881,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDispatchIndirectCommand *>( this );
     }
 
-    operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDispatchIndirectCommand *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( x, y, z );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DispatchIndirectCommand const & ) const = default;
 #else
     bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26112,24 +24928,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>::value,
                             "DispatchIndirectCommand is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.x );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.y );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.z );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayEventInfoEXT
   {
     using NativeType = VkDisplayEventInfoEXT;
@@ -26174,27 +24972,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayEventInfoEXT *>( this );
     }
 
-    operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayEventInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, displayEvent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayEventInfoEXT const & ) const = default;
 #else
     bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26216,24 +25026,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayEventInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayEventInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayEventInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT, seed, displayEventInfoEXT.displayEvent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayModeParametersKHR
   {
     using NativeType = VkDisplayModeParametersKHR;
@@ -26275,27 +25067,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModeParametersKHR *>( this );
     }
 
-    operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayModeParametersKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Extent2D const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( visibleRegion, refreshRate );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModeParametersKHR const & ) const = default;
 #else
     bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26311,23 +25113,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>::value,
                             "DisplayModeParametersKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayModeParametersKHR.visibleRegion );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayModeParametersKHR.refreshRate );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayModeCreateInfoKHR
   {
     using NativeType = VkDisplayModeCreateInfoKHR;
@@ -26380,28 +25165,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( this );
     }
 
-    operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayModeCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, parameters );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default;
 #else
     bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( parameters == rhs.parameters );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26425,26 +25222,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayModeCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayModeCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR, seed, displayModeCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModeCreateInfoKHR.parameters );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayModePropertiesKHR
   {
     using NativeType = VkDisplayModePropertiesKHR;
@@ -26472,27 +25249,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModePropertiesKHR *>( this );
     }
 
-    operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayModePropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DisplayModeKHR const &, VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( displayMode, parameters );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModePropertiesKHR const & ) const = default;
 #else
     bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26508,24 +25295,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
                             "DisplayModePropertiesKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayModePropertiesKHR.displayMode );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModePropertiesKHR.parameters );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayModeProperties2KHR
   {
     using NativeType = VkDisplayModeProperties2KHR;
@@ -26555,27 +25324,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModeProperties2KHR *>( this );
     }
 
-    operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayModeProperties2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, displayModeProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModeProperties2KHR const & ) const = default;
 #else
     bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26598,25 +25379,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayModeProperties2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeProperties2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, displayModeProperties2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, seed, displayModeProperties2KHR.displayModeProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayNativeHdrSurfaceCapabilitiesAMD
   {
     using NativeType = VkDisplayNativeHdrSurfaceCapabilitiesAMD;
@@ -26650,27 +25412,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>( this );
     }
 
-    operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, localDimmingSupport );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default;
 #else
     bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26695,25 +25467,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayNativeHdrSurfaceCapabilitiesAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const &
-                            displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayNativeHdrSurfaceCapabilitiesAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPlaneCapabilitiesKHR
   {
     using NativeType = VkDisplayPlaneCapabilitiesKHR;
@@ -26756,31 +25509,53 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR *>( this );
     }
 
-    operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::Offset2D const &,
+               VULKAN_HPP_NAMESPACE::Offset2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Offset2D const &,
+               VULKAN_HPP_NAMESPACE::Offset2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( supportedAlpha,
+                       minSrcPosition,
+                       maxSrcPosition,
+                       minSrcExtent,
+                       maxSrcExtent,
+                       minDstPosition,
+                       maxDstPosition,
+                       minDstExtent,
+                       maxDstExtent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( supportedAlpha == rhs.supportedAlpha ) && ( minSrcPosition == rhs.minSrcPosition ) &&
-             ( maxSrcPosition == rhs.maxSrcPosition ) && ( minSrcExtent == rhs.minSrcExtent ) &&
-             ( maxSrcExtent == rhs.maxSrcExtent ) && ( minDstPosition == rhs.minDstPosition ) &&
-             ( maxDstPosition == rhs.maxDstPosition ) && ( minDstExtent == rhs.minDstExtent ) &&
-             ( maxDstExtent == rhs.maxDstExtent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26804,31 +25579,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::value,
     "DisplayPlaneCapabilitiesKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR, seed, displayPlaneCapabilitiesKHR.supportedAlpha );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minSrcPosition );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxSrcPosition );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minSrcExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxSrcExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minDstPosition );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxDstPosition );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minDstExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxDstExtent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPlaneCapabilities2KHR
   {
     using NativeType = VkDisplayPlaneCapabilities2KHR;
@@ -26858,27 +25608,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR *>( this );
     }
 
-    operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, capabilities );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -26902,25 +25664,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPlaneCapabilities2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneCapabilities2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneCapabilities2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR, seed, displayPlaneCapabilities2KHR.capabilities );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPlaneInfo2KHR
   {
     using NativeType = VkDisplayPlaneInfo2KHR;
@@ -26971,28 +25714,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( this );
     }
 
-    operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPlaneInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayModeKHR const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, mode, planeIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) &&
-             ( planeIndex == rhs.planeIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27015,25 +25770,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPlaneInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPlaneInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayPlaneInfo2KHR.mode );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlaneInfo2KHR.planeIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPlanePropertiesKHR
   {
     using NativeType = VkDisplayPlanePropertiesKHR;
@@ -27061,27 +25797,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlanePropertiesKHR *>( this );
     }
 
-    operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPlanePropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DisplayKHR const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( currentDisplay, currentStackIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default;
 #else
     bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27097,23 +25843,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
                             "DisplayPlanePropertiesKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPlanePropertiesKHR.currentDisplay );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlanePropertiesKHR.currentStackIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPlaneProperties2KHR
   {
     using NativeType = VkDisplayPlaneProperties2KHR;
@@ -27143,28 +25872,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneProperties2KHR *>( this );
     }
 
-    operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPlaneProperties2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, displayPlaneProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( displayPlaneProperties == rhs.displayPlaneProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27187,25 +25927,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPlaneProperties2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneProperties2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneProperties2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, seed, displayPlaneProperties2KHR.displayPlaneProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPowerInfoEXT
   {
     using NativeType = VkDisplayPowerInfoEXT;
@@ -27249,27 +25970,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPowerInfoEXT *>( this );
     }
 
-    operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPowerInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, powerState );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPowerInfoEXT const & ) const = default;
 #else
     bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27291,24 +26024,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPowerInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPowerInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPowerInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT, seed, displayPowerInfoEXT.powerState );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPresentInfoKHR
   {
     using NativeType = VkDisplayPresentInfoKHR;
@@ -27369,28 +26084,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPresentInfoKHR *>( this );
     }
 
-    operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPresentInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Rect2D const &,
+               VULKAN_HPP_NAMESPACE::Rect2D const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcRect, dstRect, persistent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPresentInfoKHR const & ) const = default;
 #else
     bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) &&
-             ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27414,26 +26142,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPresentInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPresentInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPresentInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.srcRect );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.dstRect );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPresentInfoKHR.persistent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayPropertiesKHR
   {
     using NativeType = VkDisplayPropertiesKHR;
@@ -27471,30 +26179,49 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPropertiesKHR *>( this );
     }
 
-    operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayPropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DisplayKHR const &,
+               const char * const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( display,
+                       displayName,
+                       physicalDimensions,
+                       physicalResolution,
+                       supportedTransforms,
+                       planeReorderPossible,
+                       persistentContent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPropertiesKHR const & ) const = default;
 #else
     bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( display == rhs.display ) && ( displayName == rhs.displayName ) &&
-             ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) &&
-             ( supportedTransforms == rhs.supportedTransforms ) &&
-             ( planeReorderPossible == rhs.planeReorderPossible ) && ( persistentContent == rhs.persistentContent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27514,29 +26241,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,
                             "DisplayPropertiesKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPropertiesKHR.display );
-    VULKAN_HPP_HASH_COMBINE( const char *, seed, displayPropertiesKHR.displayName );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalDimensions );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalResolution );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, displayPropertiesKHR.supportedTransforms );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.planeReorderPossible );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.persistentContent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplayProperties2KHR
   {
     using NativeType = VkDisplayProperties2KHR;
@@ -27565,27 +26269,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayProperties2KHR *>( this );
     }
 
-    operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplayProperties2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, displayProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayProperties2KHR const & ) const = default;
 #else
     bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27607,25 +26323,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayProperties2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayProperties2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, displayProperties2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, seed, displayProperties2KHR.displayProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DisplaySurfaceCreateInfoKHR
   {
     using NativeType = VkDisplaySurfaceCreateInfoKHR;
@@ -27733,30 +26430,47 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( this );
     }
 
-    operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::DisplayModeKHR const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+               float const &,
+               VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default;
 #else
     bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( displayMode == rhs.displayMode ) && ( planeIndex == rhs.planeIndex ) &&
-             ( planeStackIndex == rhs.planeStackIndex ) && ( transform == rhs.transform ) &&
-             ( globalAlpha == rhs.globalAlpha ) && ( alphaMode == rhs.alphaMode ) && ( imageExtent == rhs.imageExtent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27789,34 +26503,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplaySurfaceCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displaySurfaceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, displaySurfaceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR, seed, displaySurfaceCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displaySurfaceCreateInfoKHR.displayMode );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeStackIndex );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.transform );
-    VULKAN_HPP_HASH_COMBINE( float, seed, displaySurfaceCreateInfoKHR.globalAlpha );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.alphaMode );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displaySurfaceCreateInfoKHR.imageExtent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DrawIndexedIndirectCommand
   {
     using NativeType = VkDrawIndexedIndirectCommand;
@@ -27882,29 +26568,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrawIndexedIndirectCommand *>( this );
     }
 
-    operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDrawIndexedIndirectCommand *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, int32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrawIndexedIndirectCommand const & ) const = default;
 #else
     bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) &&
-             ( firstIndex == rhs.firstIndex ) && ( vertexOffset == rhs.vertexOffset ) &&
-             ( firstInstance == rhs.firstInstance );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -27923,26 +26617,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>::value,
                             "DrawIndexedIndirectCommand is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.indexCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.instanceCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstIndex );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, drawIndexedIndirectCommand.vertexOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstInstance );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DrawIndirectCommand
   {
     using NativeType = VkDrawIndirectCommand;
@@ -27999,28 +26673,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrawIndirectCommand *>( this );
     }
 
-    operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDrawIndirectCommand *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( vertexCount, instanceCount, firstVertex, firstInstance );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrawIndirectCommand const & ) const = default;
 #else
     bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) &&
-             ( firstVertex == rhs.firstVertex ) && ( firstInstance == rhs.firstInstance );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28037,25 +26720,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>::value,
                             "DrawIndirectCommand is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.vertexCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.instanceCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstVertex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstInstance );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DrawMeshTasksIndirectCommandNV
   {
     using NativeType = VkDrawMeshTasksIndirectCommandNV;
@@ -28098,27 +26762,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV *>( this );
     }
 
-    operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( taskCount, firstTask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default;
 #else
     bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28135,23 +26809,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>::value,
     "DrawMeshTasksIndirectCommandNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.taskCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.firstTask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DrmFormatModifierProperties2EXT
   {
     using NativeType = VkDrmFormatModifierProperties2EXT;
@@ -28183,29 +26840,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrmFormatModifierProperties2EXT *>( this );
     }
 
-    operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDrmFormatModifierProperties2EXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint64_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( drmFormatModifier == rhs.drmFormatModifier ) &&
-             ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
-             ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28223,27 +26888,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>::value,
     "DrmFormatModifierProperties2EXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierProperties2EXT.drmFormatModifier );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR,
-                             seed,
-                             drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DrmFormatModifierPropertiesEXT
   {
     using NativeType = VkDrmFormatModifierPropertiesEXT;
@@ -28275,29 +26919,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT *>( this );
     }
 
-    operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint64_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( drmFormatModifier == rhs.drmFormatModifier ) &&
-             ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
-             ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28315,25 +26967,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>::value,
     "DrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifier );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DrmFormatModifierPropertiesList2EXT
   {
     using NativeType = VkDrmFormatModifierPropertiesList2EXT;
@@ -28377,29 +27010,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT *>( this );
     }
 
-    operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
-             ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28424,27 +27068,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DrmFormatModifierPropertiesList2EXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const &
-                            drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesList2EXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesList2EXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT *,
-                             seed,
-                             drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct DrmFormatModifierPropertiesListEXT
   {
     using NativeType = VkDrmFormatModifierPropertiesListEXT;
@@ -28488,29 +27111,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>( this );
     }
 
-    operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
-             ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28535,27 +27169,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DrmFormatModifierPropertiesListEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const &
-                            drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesListEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesListEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT *,
-                             seed,
-                             drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct EventCreateInfo
   {
     using NativeType = VkEventCreateInfo;
@@ -28598,27 +27211,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkEventCreateInfo *>( this );
     }
 
-    operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkEventCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::EventCreateFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( EventCreateInfo const & ) const = default;
 #else
     bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28640,23 +27265,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = EventCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::EventCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, eventCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, eventCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::EventCreateFlags, seed, eventCreateInfo.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExportFenceCreateInfo
   {
     using NativeType = VkExportFenceCreateInfo;
@@ -28700,27 +27308,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportFenceCreateInfo *>( this );
     }
 
-    operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportFenceCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportFenceCreateInfo const & ) const = default;
 #else
     bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28743,25 +27363,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, exportFenceCreateInfo.handleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ExportFenceWin32HandleInfoKHR
   {
@@ -28823,28 +27424,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR *>( this );
     }
 
-    operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const SECURITY_ATTRIBUTES * const &,
+               DWORD const &,
+               LPCWSTR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pAttributes, dwAccess, name );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
-             ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -28869,27 +27483,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportFenceWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportFenceWin32HandleInfoKHR.pAttributes );
-    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportFenceWin32HandleInfoKHR.dwAccess );
-    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportFenceWin32HandleInfoKHR.name );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExportMemoryAllocateInfo
@@ -28935,27 +27528,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryAllocateInfo *>( this );
     }
 
-    operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportMemoryAllocateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryAllocateInfo const & ) const = default;
 #else
     bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -28979,25 +27584,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, exportMemoryAllocateInfo.handleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExportMemoryAllocateInfoNV
   {
     using NativeType = VkExportMemoryAllocateInfoNV;
@@ -29042,27 +27628,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryAllocateInfoNV *>( this );
     }
 
-    operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportMemoryAllocateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default;
 #else
     bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -29085,25 +27683,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ExportMemoryAllocateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, exportMemoryAllocateInfoNV.handleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ExportMemoryWin32HandleInfoKHR
   {
@@ -29165,28 +27744,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>( this );
     }
 
-    operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const SECURITY_ATTRIBUTES * const &,
+               DWORD const &,
+               LPCWSTR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pAttributes, dwAccess, name );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
-             ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -29211,27 +27803,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportMemoryWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoKHR.pAttributes );
-    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoKHR.dwAccess );
-    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportMemoryWin32HandleInfoKHR.name );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -29287,28 +27858,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>( this );
     }
 
-    operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const SECURITY_ATTRIBUTES * const &,
+               DWORD const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pAttributes, dwAccess );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default;
 #  else
     bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
-             ( dwAccess == rhs.dwAccess );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -29332,26 +27915,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportMemoryWin32HandleInfoNV;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoNV.pAttributes );
-    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoNV.dwAccess );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExportSemaphoreCreateInfo
@@ -29398,27 +27961,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportSemaphoreCreateInfo *>( this );
     }
 
-    operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportSemaphoreCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default;
 #else
     bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -29442,25 +28017,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, exportSemaphoreCreateInfo.handleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ExportSemaphoreWin32HandleInfoKHR
   {
@@ -29523,28 +28079,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>( this );
     }
 
-    operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const SECURITY_ATTRIBUTES * const &,
+               DWORD const &,
+               LPCWSTR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pAttributes, dwAccess, name );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
-             ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -29569,27 +28138,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportSemaphoreWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const &
-                            exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportSemaphoreWin32HandleInfoKHR.pAttributes );
-    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportSemaphoreWin32HandleInfoKHR.dwAccess );
-    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportSemaphoreWin32HandleInfoKHR.name );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExtensionProperties
@@ -29619,27 +28167,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExtensionProperties *>( this );
     }
 
-    operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExtensionProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( extensionName, specVersion );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExtensionProperties const & ) const = default;
 #else
     bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( extensionName == rhs.extensionName ) && ( specVersion == rhs.specVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -29654,26 +28212,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExtensionProperties>::value,
                             "ExtensionProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExtensionProperties>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, extensionProperties.extensionName[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extensionProperties.specVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalMemoryProperties
   {
     using NativeType = VkExternalMemoryProperties;
@@ -29703,29 +28241,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryProperties *>( this );
     }
 
-    operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalMemoryProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryProperties const & ) const = default;
 #else
     bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) &&
-             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
-             ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -29743,28 +28291,6 @@ namespace VULKAN_HPP_NAMESPACE
                             "ExternalMemoryProperties is not nothrow_move_constructible!" );
   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags, seed, externalMemoryProperties.externalMemoryFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags,
-                             seed,
-                             externalMemoryProperties.exportFromImportedHandleTypes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryProperties.compatibleHandleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalBufferProperties
   {
     using NativeType = VkExternalBufferProperties;
@@ -29793,28 +28319,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalBufferProperties *>( this );
     }
 
-    operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalBufferProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, externalMemoryProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalBufferProperties const & ) const = default;
 #else
     bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( externalMemoryProperties == rhs.externalMemoryProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -29838,25 +28375,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalBufferPropertiesKHR = ExternalBufferProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalBufferProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, externalBufferProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalBufferProperties.externalMemoryProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalFenceProperties
   {
     using NativeType = VkExternalFenceProperties;
@@ -29889,30 +28407,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalFenceProperties *>( this );
     }
 
-    operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalFenceProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalFenceProperties const & ) const = default;
 #else
     bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
-             ( compatibleHandleTypes == rhs.compatibleHandleTypes ) &&
-             ( externalFenceFeatures == rhs.externalFenceFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -29938,29 +28467,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalFencePropertiesKHR = ExternalFenceProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFenceProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, externalFenceProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.exportFromImportedHandleTypes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.compatibleHandleTypes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags, seed, externalFenceProperties.externalFenceFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct ExternalFormatANDROID
   {
@@ -30003,27 +28509,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalFormatANDROID *>( this );
     }
 
-    operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalFormatANDROID *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, externalFormat );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalFormatANDROID const & ) const = default;
 #  else
     bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -30044,25 +28560,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExternalFormatANDROID;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFormatANDROID.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, externalFormatANDROID.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, externalFormatANDROID.externalFormat );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ExternalImageFormatProperties
@@ -30095,28 +28592,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalImageFormatProperties *>( this );
     }
 
-    operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalImageFormatProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, externalMemoryProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalImageFormatProperties const & ) const = default;
 #else
     bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( externalMemoryProperties == rhs.externalMemoryProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30141,25 +28649,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalImageFormatProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, externalImageFormatProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalImageFormatProperties.externalMemoryProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageFormatProperties
   {
     using NativeType = VkImageFormatProperties;
@@ -30193,29 +28682,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageFormatProperties *>( this );
     }
 
-    operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageFormatProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Extent3D const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatProperties const & ) const = default;
 #else
     bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) &&
-             ( maxArrayLayers == rhs.maxArrayLayers ) && ( sampleCounts == rhs.sampleCounts ) &&
-             ( maxResourceSize == rhs.maxResourceSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30233,26 +28734,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::value,
                             "ImageFormatProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageFormatProperties.maxExtent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxMipLevels );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxArrayLayers );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, imageFormatProperties.sampleCounts );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageFormatProperties.maxResourceSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalImageFormatPropertiesNV
   {
     using NativeType = VkExternalImageFormatPropertiesNV;
@@ -30286,30 +28767,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalImageFormatPropertiesNV *>( this );
     }
 
-    operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalImageFormatPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageFormatProperties const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default;
 #else
     bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( imageFormatProperties == rhs.imageFormatProperties ) &&
-             ( externalMemoryFeatures == rhs.externalMemoryFeatures ) &&
-             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
-             ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30328,33 +28820,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::value,
     "ExternalImageFormatPropertiesNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, externalImageFormatPropertiesNV.imageFormatProperties );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV,
-                             seed,
-                             externalImageFormatPropertiesNV.externalMemoryFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV,
-                             seed,
-                             externalImageFormatPropertiesNV.exportFromImportedHandleTypes );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV,
-                             seed,
-                             externalImageFormatPropertiesNV.compatibleHandleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalMemoryBufferCreateInfo
   {
     using NativeType = VkExternalMemoryBufferCreateInfo;
@@ -30400,27 +28865,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>( this );
     }
 
-    operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalMemoryBufferCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default;
 #else
     bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30445,25 +28922,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryBufferCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryBufferCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryBufferCreateInfo.handleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalMemoryImageCreateInfo
   {
     using NativeType = VkExternalMemoryImageCreateInfo;
@@ -30509,27 +28967,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryImageCreateInfo *>( this );
     }
 
-    operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalMemoryImageCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default;
 #else
     bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30554,25 +29024,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryImageCreateInfo.handleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalMemoryImageCreateInfoNV
   {
     using NativeType = VkExternalMemoryImageCreateInfoNV;
@@ -30618,27 +29069,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>( this );
     }
 
-    operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default;
 #else
     bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30662,26 +29125,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ExternalMemoryImageCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, externalMemoryImageCreateInfoNV.handleTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ExternalSemaphoreProperties
   {
     using NativeType = VkExternalSemaphoreProperties;
@@ -30715,30 +29158,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalSemaphoreProperties *>( this );
     }
 
-    operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkExternalSemaphoreProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalSemaphoreProperties const & ) const = default;
 #else
     bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
-             ( compatibleHandleTypes == rhs.compatibleHandleTypes ) &&
-             ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30765,31 +29219,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalSemaphoreProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, externalSemaphoreProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags,
-                             seed,
-                             externalSemaphoreProperties.exportFromImportedHandleTypes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, externalSemaphoreProperties.compatibleHandleTypes );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags,
-                             seed,
-                             externalSemaphoreProperties.externalSemaphoreFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FenceCreateInfo
   {
     using NativeType = VkFenceCreateInfo;
@@ -30832,27 +29261,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFenceCreateInfo *>( this );
     }
 
-    operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFenceCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::FenceCreateFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FenceCreateInfo const & ) const = default;
 #else
     bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30874,23 +29315,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FenceCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceCreateFlags, seed, fenceCreateInfo.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FenceGetFdInfoKHR
   {
     using NativeType = VkFenceGetFdInfoKHR;
@@ -30943,28 +29367,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFenceGetFdInfoKHR *>( this );
     }
 
-    operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFenceGetFdInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Fence const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fence, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FenceGetFdInfoKHR const & ) const = default;
 #else
     bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -30988,25 +29424,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FenceGetFdInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetFdInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetFdInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetFdInfoKHR.fence );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetFdInfoKHR.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct FenceGetWin32HandleInfoKHR
   {
@@ -31062,28 +29479,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( this );
     }
 
-    operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Fence const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fence, handleType );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -31107,27 +29536,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = FenceGetWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetWin32HandleInfoKHR.fence );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetWin32HandleInfoKHR.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct FilterCubicImageViewImageFormatPropertiesEXT
@@ -31166,28 +29574,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>( this );
     }
 
-    operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, filterCubic, filterCubicMinmax );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default;
 #else
     bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) &&
-             ( filterCubicMinmax == rhs.filterCubicMinmax );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -31213,28 +29633,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FilterCubicImageViewImageFormatPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const &
-                            filterCubicImageViewImageFormatPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, filterCubicImageViewImageFormatPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, filterCubicImageViewImageFormatPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FormatProperties
   {
     using NativeType = VkFormatProperties;
@@ -31264,28 +29662,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFormatProperties *>( this );
     }
 
-    operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFormatProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FormatProperties const & ) const = default;
 #else
     bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( linearTilingFeatures == rhs.linearTilingFeatures ) &&
-             ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -31301,23 +29710,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::FormatProperties>::value,
                             "FormatProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.linearTilingFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.optimalTilingFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.bufferFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FormatProperties2
   {
     using NativeType = VkFormatProperties2;
@@ -31346,27 +29738,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFormatProperties2 *>( this );
     }
 
-    operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFormatProperties2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::FormatProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, formatProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FormatProperties2 const & ) const = default;
 #else
     bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -31389,23 +29792,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using FormatProperties2KHR = FormatProperties2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatProperties, seed, formatProperties2.formatProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FormatProperties3KHR
   {
     using NativeType = VkFormatProperties3KHR;
@@ -31438,28 +29824,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkFormatProperties3KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFormatProperties3KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFormatProperties3KHR *>( this );
     }
 
-    operator VkFormatProperties3KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFormatProperties3KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFormatProperties3KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FormatProperties3KHR const & ) const = default;
 #else
     bool operator==( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) &&
-             ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -31483,28 +29882,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FormatProperties3KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties3KHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::FormatProperties3KHR const & formatProperties3KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties3KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties3KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.linearTilingFeatures );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.optimalTilingFeatures );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.bufferFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FragmentShadingRateAttachmentInfoKHR
   {
     using NativeType = VkFragmentShadingRateAttachmentInfoKHR;
@@ -31561,29 +29938,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR *>( this );
     }
 
-    operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default;
 #else
     bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) &&
-             ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -31608,28 +29996,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FragmentShadingRateAttachmentInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const &
-                            fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fragmentShadingRateAttachmentInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, fragmentShadingRateAttachmentInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *,
-                             seed,
-                             fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FramebufferAttachmentImageInfo
   {
     using NativeType = VkFramebufferAttachmentImageInfo;
@@ -31755,29 +30121,45 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferAttachmentImageInfo *>( this );
     }
 
-    operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFramebufferAttachmentImageInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Format * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default;
 #else
     bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) &&
-             ( width == rhs.width ) && ( height == rhs.height ) && ( layerCount == rhs.layerCount ) &&
-             ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -31808,30 +30190,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentImageInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentImageInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, framebufferAttachmentImageInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, framebufferAttachmentImageInfo.usage );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.width );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.height );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.layerCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.viewFormatCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, framebufferAttachmentImageInfo.pViewFormats );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FramebufferAttachmentsCreateInfo
   {
     using NativeType = VkFramebufferAttachmentsCreateInfo;
@@ -31906,29 +30264,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>( this );
     }
 
-    operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFramebufferAttachmentsCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default;
 #else
     bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) &&
-             ( pAttachmentImageInfos == rhs.pAttachmentImageInfos );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -31954,28 +30323,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentsCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentsCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo *,
-                             seed,
-                             framebufferAttachmentsCreateInfo.pAttachmentImageInfos );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FramebufferCreateInfo
   {
     using NativeType = VkFramebufferCreateInfo;
@@ -32097,30 +30444,45 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferCreateInfo *>( this );
     }
 
-    operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFramebufferCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::FramebufferCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::RenderPass const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ImageView * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferCreateInfo const & ) const = default;
 #else
     bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( renderPass == rhs.renderPass ) && ( attachmentCount == rhs.attachmentCount ) &&
-             ( pAttachments == rhs.pAttachments ) && ( width == rhs.width ) && ( height == rhs.height ) &&
-             ( layers == rhs.layers );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -32148,30 +30510,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FramebufferCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FramebufferCreateFlags, seed, framebufferCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, framebufferCreateInfo.renderPass );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.attachmentCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageView *, seed, framebufferCreateInfo.pAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.width );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.height );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.layers );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct FramebufferMixedSamplesCombinationNV
   {
     using NativeType = VkFramebufferMixedSamplesCombinationNV;
@@ -32211,30 +30549,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV *>( this );
     }
 
-    operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::CoverageReductionModeNV const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default;
 #else
     bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( coverageReductionMode == rhs.coverageReductionMode ) &&
-             ( rasterizationSamples == rhs.rasterizationSamples ) &&
-             ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -32262,31 +30612,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FramebufferMixedSamplesCombinationNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const &
-                            framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferMixedSamplesCombinationNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, framebufferMixedSamplesCombinationNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::CoverageReductionModeNV, seed, framebufferMixedSamplesCombinationNV.coverageReductionMode );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, framebufferMixedSamplesCombinationNV.rasterizationSamples );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.depthStencilSamples );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.colorSamples );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct IndirectCommandsStreamNV
   {
     using NativeType = VkIndirectCommandsStreamNV;
@@ -32329,27 +30654,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIndirectCommandsStreamNV *>( this );
     }
 
-    operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkIndirectCommandsStreamNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( buffer, offset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IndirectCommandsStreamNV const & ) const = default;
 #else
     bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( buffer == rhs.buffer ) && ( offset == rhs.offset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -32365,23 +30700,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>::value,
                             "IndirectCommandsStreamNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, indirectCommandsStreamNV.buffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, indirectCommandsStreamNV.offset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GeneratedCommandsInfoNV
   {
     using NativeType = VkGeneratedCommandsInfoNV;
@@ -32573,35 +30891,65 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeneratedCommandsInfoNV *>( this );
     }
 
-    operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGeneratedCommandsInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+               VULKAN_HPP_NAMESPACE::Pipeline const &,
+               VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       pipelineBindPoint,
+                       pipeline,
+                       indirectCommandsLayout,
+                       streamCount,
+                       pStreams,
+                       sequencesCount,
+                       preprocessBuffer,
+                       preprocessOffset,
+                       preprocessSize,
+                       sequencesCountBuffer,
+                       sequencesCountOffset,
+                       sequencesIndexBuffer,
+                       sequencesIndexOffset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeneratedCommandsInfoNV const & ) const = default;
 #else
     bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
-             ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) &&
-             ( streamCount == rhs.streamCount ) && ( pStreams == rhs.pStreams ) &&
-             ( sequencesCount == rhs.sequencesCount ) && ( preprocessBuffer == rhs.preprocessBuffer ) &&
-             ( preprocessOffset == rhs.preprocessOffset ) && ( preprocessSize == rhs.preprocessSize ) &&
-             ( sequencesCountBuffer == rhs.sequencesCountBuffer ) &&
-             ( sequencesCountOffset == rhs.sequencesCountOffset ) &&
-             ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) &&
-             ( sequencesIndexOffset == rhs.sequencesIndexOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -32636,38 +30984,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeneratedCommandsInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsInfoNV.pipelineBindPoint );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsInfoNV.pipeline );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, seed, generatedCommandsInfoNV.indirectCommandsLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.streamCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV *, seed, generatedCommandsInfoNV.pStreams );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.sequencesCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.preprocessBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessSize );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesCountBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesCountOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesIndexBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesIndexOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GeneratedCommandsMemoryRequirementsInfoNV
   {
     using NativeType = VkGeneratedCommandsMemoryRequirementsInfoNV;
@@ -32745,29 +31061,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( this );
     }
 
-    operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+               VULKAN_HPP_NAMESPACE::Pipeline const &,
+               VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default;
 #else
     bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
-             ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) &&
-             ( maxSequencesCount == rhs.maxSequencesCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -32795,31 +31124,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeneratedCommandsMemoryRequirementsInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const &
-                            generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsMemoryRequirementsInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsMemoryRequirementsInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsMemoryRequirementsInfoNV.pipeline );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV,
-                             seed,
-                             generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct VertexInputBindingDescription
   {
     using NativeType = VkVertexInputBindingDescription;
@@ -32873,27 +31177,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputBindingDescription *>( this );
     }
 
-    operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVertexInputBindingDescription *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::VertexInputRate const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( binding, stride, inputRate );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputBindingDescription const & ) const = default;
 #else
     bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -32911,24 +31225,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>::value,
     "VertexInputBindingDescription is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.binding );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.stride );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription.inputRate );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct VertexInputAttributeDescription
   {
     using NativeType = VkVertexInputAttributeDescription;
@@ -32989,28 +31285,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputAttributeDescription *>( this );
     }
 
-    operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVertexInputAttributeDescription *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::Format const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( location, binding, format, offset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputAttributeDescription const & ) const = default;
 #else
     bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) &&
-             ( offset == rhs.offset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -33029,26 +31334,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>::value,
     "VertexInputAttributeDescription is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.location );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.binding );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription.format );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.offset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineVertexInputStateCreateInfo
   {
     using NativeType = VkPipelineVertexInputStateCreateInfo;
@@ -33170,31 +31455,49 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo *>( this );
     }
 
-    operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       vertexBindingDescriptionCount,
+                       pVertexBindingDescriptions,
+                       vertexAttributeDescriptionCount,
+                       pVertexAttributeDescriptions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) &&
-             ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) &&
-             ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) &&
-             ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -33222,33 +31525,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineVertexInputStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const &
-                            pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags, seed, pipelineVertexInputStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription *,
-                             seed,
-                             pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription *,
-                             seed,
-                             pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineInputAssemblyStateCreateInfo
   {
     using NativeType = VkPipelineInputAssemblyStateCreateInfo;
@@ -33314,28 +31590,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo *>( this );
     }
 
-    operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::PrimitiveTopology const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, topology, primitiveRestartEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( topology == rhs.topology ) && ( primitiveRestartEnable == rhs.primitiveRestartEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -33361,29 +31650,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineInputAssemblyStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const &
-                            pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInputAssemblyStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInputAssemblyStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags, seed, pipelineInputAssemblyStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PrimitiveTopology, seed, pipelineInputAssemblyStateCreateInfo.topology );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineTessellationStateCreateInfo
   {
     using NativeType = VkPipelineTessellationStateCreateInfo;
@@ -33440,28 +31706,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo *>( this );
     }
 
-    operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineTessellationStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, patchControlPoints );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( patchControlPoints == rhs.patchControlPoints );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -33486,26 +31764,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineTessellationStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const &
-                            pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags, seed, pipelineTessellationStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineTessellationStateCreateInfo.patchControlPoints );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineViewportStateCreateInfo
   {
     using NativeType = VkPipelineViewportStateCreateInfo;
@@ -33622,29 +31880,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportStateCreateInfo *>( this );
     }
 
-    operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineViewportStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Viewport * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( viewportCount == rhs.viewportCount ) && ( pViewports == rhs.pViewports ) &&
-             ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -33672,30 +31944,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags, seed, pipelineViewportStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.viewportCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Viewport *, seed, pipelineViewportStateCreateInfo.pViewports );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.scissorCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineViewportStateCreateInfo.pScissors );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRasterizationStateCreateInfo
   {
     using NativeType = VkPipelineRasterizationStateCreateInfo;
@@ -33832,33 +32080,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo *>( this );
     }
 
-    operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::PolygonMode const &,
+               VULKAN_HPP_NAMESPACE::CullModeFlags const &,
+               VULKAN_HPP_NAMESPACE::FrontFace const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       depthClampEnable,
+                       rasterizerDiscardEnable,
+                       polygonMode,
+                       cullMode,
+                       frontFace,
+                       depthBiasEnable,
+                       depthBiasConstantFactor,
+                       depthBiasClamp,
+                       depthBiasSlopeFactor,
+                       lineWidth );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( depthClampEnable == rhs.depthClampEnable ) &&
-             ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) && ( polygonMode == rhs.polygonMode ) &&
-             ( cullMode == rhs.cullMode ) && ( frontFace == rhs.frontFace ) &&
-             ( depthBiasEnable == rhs.depthBiasEnable ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) &&
-             ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) &&
-             ( lineWidth == rhs.lineWidth );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -33892,38 +32168,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const &
-                            pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags, seed, pipelineRasterizationStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthClampEnable );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PolygonMode, seed, pipelineRasterizationStateCreateInfo.polygonMode );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CullModeFlags, seed, pipelineRasterizationStateCreateInfo.cullMode );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FrontFace, seed, pipelineRasterizationStateCreateInfo.frontFace );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthBiasEnable );
-    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor );
-    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasClamp );
-    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor );
-    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.lineWidth );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineMultisampleStateCreateInfo
   {
     using NativeType = VkPipelineMultisampleStateCreateInfo;
@@ -34025,31 +32269,53 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo *>( this );
     }
 
-    operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               float const &,
+               const VULKAN_HPP_NAMESPACE::SampleMask * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       rasterizationSamples,
+                       sampleShadingEnable,
+                       minSampleShading,
+                       pSampleMask,
+                       alphaToCoverageEnable,
+                       alphaToOneEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( rasterizationSamples == rhs.rasterizationSamples ) &&
-             ( sampleShadingEnable == rhs.sampleShadingEnable ) && ( minSampleShading == rhs.minSampleShading ) &&
-             ( pSampleMask == rhs.pSampleMask ) && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) &&
-             ( alphaToOneEnable == rhs.alphaToOneEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -34079,35 +32345,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineMultisampleStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const &
-                            pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineMultisampleStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineMultisampleStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags, seed, pipelineMultisampleStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, pipelineMultisampleStateCreateInfo.rasterizationSamples );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable );
-    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineMultisampleStateCreateInfo.minSampleShading );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SampleMask *, seed, pipelineMultisampleStateCreateInfo.pSampleMask );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct StencilOpState
   {
     using NativeType = VkStencilOpState;
@@ -34191,29 +32428,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkStencilOpState *>( this );
     }
 
-    operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkStencilOpState *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StencilOp const &,
+               VULKAN_HPP_NAMESPACE::StencilOp const &,
+               VULKAN_HPP_NAMESPACE::StencilOp const &,
+               VULKAN_HPP_NAMESPACE::CompareOp const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( StencilOpState const & ) const = default;
 #else
     bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) &&
-             ( compareOp == rhs.compareOp ) && ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) &&
-             ( reference == rhs.reference );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -34233,27 +32484,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StencilOpState>::value,
                             "StencilOpState is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::StencilOpState>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.failOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.passOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.depthFailOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, stencilOpState.compareOp );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.compareMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.writeMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.reference );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineDepthStencilStateCreateInfo
   {
     using NativeType = VkPipelineDepthStencilStateCreateInfo;
@@ -34382,31 +32612,59 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo *>( this );
     }
 
-    operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::CompareOp const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::StencilOpState const &,
+               VULKAN_HPP_NAMESPACE::StencilOpState const &,
+               float const &,
+               float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       depthTestEnable,
+                       depthWriteEnable,
+                       depthCompareOp,
+                       depthBoundsTestEnable,
+                       stencilTestEnable,
+                       front,
+                       back,
+                       minDepthBounds,
+                       maxDepthBounds );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( depthTestEnable == rhs.depthTestEnable ) && ( depthWriteEnable == rhs.depthWriteEnable ) &&
-             ( depthCompareOp == rhs.depthCompareOp ) && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) &&
-             ( stencilTestEnable == rhs.stencilTestEnable ) && ( front == rhs.front ) && ( back == rhs.back ) &&
-             ( minDepthBounds == rhs.minDepthBounds ) && ( maxDepthBounds == rhs.maxDepthBounds );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -34439,37 +32697,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineDepthStencilStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const &
-                            pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDepthStencilStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDepthStencilStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags, seed, pipelineDepthStencilStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthTestEnable );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::CompareOp, seed, pipelineDepthStencilStateCreateInfo.depthCompareOp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.front );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.back );
-    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.minDepthBounds );
-    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineColorBlendAttachmentState
   {
     using NativeType = VkPipelineColorBlendAttachmentState;
@@ -34569,30 +32796,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineColorBlendAttachmentState *>( this );
     }
 
-    operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineColorBlendAttachmentState *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::BlendFactor const &,
+               VULKAN_HPP_NAMESPACE::BlendFactor const &,
+               VULKAN_HPP_NAMESPACE::BlendOp const &,
+               VULKAN_HPP_NAMESPACE::BlendFactor const &,
+               VULKAN_HPP_NAMESPACE::BlendFactor const &,
+               VULKAN_HPP_NAMESPACE::BlendOp const &,
+               VULKAN_HPP_NAMESPACE::ColorComponentFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( blendEnable,
+                       srcColorBlendFactor,
+                       dstColorBlendFactor,
+                       colorBlendOp,
+                       srcAlphaBlendFactor,
+                       dstAlphaBlendFactor,
+                       alphaBlendOp,
+                       colorWriteMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default;
 #else
     bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( blendEnable == rhs.blendEnable ) && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) &&
-             ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) &&
-             ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) &&
-             ( alphaBlendOp == rhs.alphaBlendOp ) && ( colorWriteMask == rhs.colorWriteMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -34615,34 +32863,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>::value,
     "PipelineColorBlendAttachmentState is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const &
-                            pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAttachmentState.blendEnable );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcColorBlendFactor );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstColorBlendFactor );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.colorBlendOp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.alphaBlendOp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ColorComponentFlags, seed, pipelineColorBlendAttachmentState.colorWriteMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineColorBlendStateCreateInfo
   {
     using NativeType = VkPipelineColorBlendStateCreateInfo;
@@ -34762,30 +32982,44 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo *>( this );
     }
 
-    operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::LogicOp const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( logicOpEnable == rhs.logicOpEnable ) && ( logicOp == rhs.logicOp ) &&
-             ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
-             ( blendConstants == rhs.blendConstants );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -34814,35 +33048,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineColorBlendStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const &
-                            pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags, seed, pipelineColorBlendStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendStateCreateInfo.logicOpEnable );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LogicOp, seed, pipelineColorBlendStateCreateInfo.logicOp );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorBlendStateCreateInfo.attachmentCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState *,
-                             seed,
-                             pipelineColorBlendStateCreateInfo.pAttachments );
-    for ( size_t i = 0; i < 4; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( float, seed, pipelineColorBlendStateCreateInfo.blendConstants[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineDynamicStateCreateInfo
   {
     using NativeType = VkPipelineDynamicStateCreateInfo;
@@ -34927,28 +33132,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo *>( this );
     }
 
-    operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineDynamicStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DynamicState * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( dynamicStateCount == rhs.dynamicStateCount ) && ( pDynamicStates == rhs.pDynamicStates );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -34974,28 +33192,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineDynamicStateCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDynamicStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDynamicStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags, seed, pipelineDynamicStateCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDynamicStateCreateInfo.dynamicStateCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DynamicState *, seed, pipelineDynamicStateCreateInfo.pDynamicStates );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GraphicsPipelineCreateInfo
   {
     using NativeType = VkGraphicsPipelineCreateInfo;
@@ -35232,35 +33428,73 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( this );
     }
 
-    operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGraphicsPipelineCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo * const &,
+               VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+               VULKAN_HPP_NAMESPACE::RenderPass const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Pipeline const &,
+               int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       stageCount,
+                       pStages,
+                       pVertexInputState,
+                       pInputAssemblyState,
+                       pTessellationState,
+                       pViewportState,
+                       pRasterizationState,
+                       pMultisampleState,
+                       pDepthStencilState,
+                       pColorBlendState,
+                       pDynamicState,
+                       layout,
+                       renderPass,
+                       subpass,
+                       basePipelineHandle,
+                       basePipelineIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default;
 #else
     bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
-             ( pVertexInputState == rhs.pVertexInputState ) && ( pInputAssemblyState == rhs.pInputAssemblyState ) &&
-             ( pTessellationState == rhs.pTessellationState ) && ( pViewportState == rhs.pViewportState ) &&
-             ( pRasterizationState == rhs.pRasterizationState ) && ( pMultisampleState == rhs.pMultisampleState ) &&
-             ( pDepthStencilState == rhs.pDepthStencilState ) && ( pColorBlendState == rhs.pColorBlendState ) &&
-             ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) && ( renderPass == rhs.renderPass ) &&
-             ( subpass == rhs.subpass ) && ( basePipelineHandle == rhs.basePipelineHandle ) &&
-             ( basePipelineIndex == rhs.basePipelineIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -35299,57 +33533,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GraphicsPipelineCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, graphicsPipelineCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.stageCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsPipelineCreateInfo.pStages );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *,
-                             seed,
-                             graphicsPipelineCreateInfo.pVertexInputState );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo *,
-                             seed,
-                             graphicsPipelineCreateInfo.pInputAssemblyState );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *,
-                             seed,
-                             graphicsPipelineCreateInfo.pTessellationState );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo *, seed, graphicsPipelineCreateInfo.pViewportState );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo *,
-                             seed,
-                             graphicsPipelineCreateInfo.pRasterizationState );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo *,
-                             seed,
-                             graphicsPipelineCreateInfo.pMultisampleState );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo *,
-                             seed,
-                             graphicsPipelineCreateInfo.pDepthStencilState );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo *,
-                             seed,
-                             graphicsPipelineCreateInfo.pColorBlendState );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *, seed, graphicsPipelineCreateInfo.pDynamicState );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, graphicsPipelineCreateInfo.layout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, graphicsPipelineCreateInfo.renderPass );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.subpass );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, graphicsPipelineCreateInfo.basePipelineHandle );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, graphicsPipelineCreateInfo.basePipelineIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GraphicsShaderGroupCreateInfoNV
   {
     using NativeType = VkGraphicsShaderGroupCreateInfoNV;
@@ -35445,29 +33628,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV *>( this );
     }
 
-    operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default;
 #else
     bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) &&
-             ( pStages == rhs.pStages ) && ( pVertexInputState == rhs.pVertexInputState ) &&
-             ( pTessellationState == rhs.pTessellationState );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -35494,33 +33690,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GraphicsShaderGroupCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsShaderGroupCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsShaderGroupCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsShaderGroupCreateInfoNV.stageCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsShaderGroupCreateInfoNV.pStages );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *,
-                             seed,
-                             graphicsShaderGroupCreateInfoNV.pVertexInputState );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *,
-                             seed,
-                             graphicsShaderGroupCreateInfoNV.pTessellationState );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct GraphicsPipelineShaderGroupsCreateInfoNV
   {
     using NativeType = VkGraphicsPipelineShaderGroupsCreateInfoNV;
@@ -35632,28 +33801,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV *>( this );
     }
 
-    operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Pipeline * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default;
 #else
     bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) &&
-             ( pGroups == rhs.pGroups ) && ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -35681,31 +33864,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GraphicsPipelineShaderGroupsCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const &
-                            graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineShaderGroupsCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV *,
-                             seed,
-                             graphicsPipelineShaderGroupsCreateInfoNV.pGroups );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Pipeline *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct XYColorEXT
   {
     using NativeType = VkXYColorEXT;
@@ -35745,27 +33903,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkXYColorEXT *>( this );
     }
 
-    operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkXYColorEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<float const &, float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( x, y );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( XYColorEXT const & ) const = default;
 #else
     bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( x == rhs.x ) && ( y == rhs.y );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -35780,22 +33948,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::XYColorEXT>::value,
                             "XYColorEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::XYColorEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.x );
-    VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.y );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct HdrMetadataEXT
   {
     using NativeType = VkHdrMetadataEXT;
@@ -35898,31 +34050,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkHdrMetadataEXT *>( this );
     }
 
-    operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkHdrMetadataEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+               VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+               VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+               VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+               float const &,
+               float const &,
+               float const &,
+               float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       displayPrimaryRed,
+                       displayPrimaryGreen,
+                       displayPrimaryBlue,
+                       whitePoint,
+                       maxLuminance,
+                       minLuminance,
+                       maxContentLightLevel,
+                       maxFrameAverageLightLevel );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( HdrMetadataEXT const & ) const = default;
 #else
     bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPrimaryRed == rhs.displayPrimaryRed ) &&
-             ( displayPrimaryGreen == rhs.displayPrimaryGreen ) && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) &&
-             ( whitePoint == rhs.whitePoint ) && ( maxLuminance == rhs.maxLuminance ) &&
-             ( minLuminance == rhs.minLuminance ) && ( maxContentLightLevel == rhs.maxContentLightLevel ) &&
-             ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -35951,30 +34127,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = HdrMetadataEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, hdrMetadataEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, hdrMetadataEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryRed );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryGreen );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryBlue );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.whitePoint );
-    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxLuminance );
-    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.minLuminance );
-    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxContentLightLevel );
-    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxFrameAverageLightLevel );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct HeadlessSurfaceCreateInfoEXT
   {
     using NativeType = VkHeadlessSurfaceCreateInfoEXT;
@@ -36018,27 +34170,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( this );
     }
 
-    operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default;
 #else
     bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -36062,25 +34226,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = HeadlessSurfaceCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, headlessSurfaceCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, headlessSurfaceCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT, seed, headlessSurfaceCreateInfoEXT.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_IOS_MVK )
   struct IOSSurfaceCreateInfoMVK
   {
@@ -36132,27 +34277,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( this );
     }
 
-    operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK const &,
+               const void * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pView );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default;
 #  else
     bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -36175,26 +34333,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = IOSSurfaceCreateInfoMVK;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, iOSSurfaceCreateInfoMVK.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK, seed, iOSSurfaceCreateInfoMVK.flags );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pView );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
 
   struct ImageBlit
@@ -36257,28 +34395,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageBlit *>( this );
     }
 
-    operator VkImageBlit &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageBlit &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageBlit *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageBlit const & ) const = default;
 #else
     bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) &&
-             ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -36295,30 +34445,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageBlit>::value,
                             "ImageBlit is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageBlit>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.srcSubresource );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.srcOffsets[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.dstSubresource );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.dstOffsets[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct ImageFormatConstraintsInfoFUCHSIA
   {
@@ -36411,30 +34537,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageFormatConstraintsInfoFUCHSIA *>( this );
     }
 
-    operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageCreateInfo const &,
+               VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA const &,
+               uint64_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       imageCreateInfo,
+                       requiredFormatFeatures,
+                       flags,
+                       sysmemPixelFormat,
+                       colorSpaceCount,
+                       pColorSpaces );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) &&
-             ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && ( flags == rhs.flags ) &&
-             ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( colorSpaceCount == rhs.colorSpaceCount ) &&
-             ( pColorSpaces == rhs.pColorSpaces );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -36462,34 +34609,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImageFormatConstraintsInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const &
-                            imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatConstraintsInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatConstraintsInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageCreateInfo, seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA, seed, imageFormatConstraintsInfoFUCHSIA.flags );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA *, seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -36589,30 +34708,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( this );
     }
 
-    operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageConstraintsInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA * const &,
+               VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &,
+               VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( formatConstraintsCount == rhs.formatConstraintsCount ) &&
-             ( pFormatConstraints == rhs.pFormatConstraints ) &&
-             ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -36638,33 +34769,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImageConstraintsInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageConstraintsInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageConstraintsInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA *,
-                             seed,
-                             imageConstraintsInfoFUCHSIA.pFormatConstraints );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA,
-                             seed,
-                             imageConstraintsInfoFUCHSIA.bufferCollectionConstraints );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA, seed, imageConstraintsInfoFUCHSIA.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImageCopy
@@ -36734,28 +34838,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageCopy *>( this );
     }
 
-    operator VkImageCopy &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageCopy &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageCopy *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageCopy const & ) const = default;
 #else
     bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
-             ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -36773,25 +34890,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageCopy>::value,
                             "ImageCopy is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageCopy>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.srcSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.srcOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.dstSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.dstOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy.extent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubresourceLayout
   {
     using NativeType = VkSubresourceLayout;
@@ -36824,28 +34922,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubresourceLayout *>( this );
     }
 
-    operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubresourceLayout *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( offset, size, rowPitch, arrayPitch, depthPitch );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubresourceLayout const & ) const = default;
 #else
     bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) &&
-             ( arrayPitch == rhs.arrayPitch ) && ( depthPitch == rhs.depthPitch );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -36863,25 +34974,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubresourceLayout>::value,
                             "SubresourceLayout is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.size );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.rowPitch );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.arrayPitch );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.depthPitch );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageDrmFormatModifierExplicitCreateInfoEXT
   {
     using NativeType = VkImageDrmFormatModifierExplicitCreateInfoEXT;
@@ -36972,29 +35064,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>( this );
     }
 
-    operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint64_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SubresourceLayout * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) &&
-             ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
-             ( pPlaneLayouts == rhs.pPlaneLayouts );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -37021,29 +35125,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageDrmFormatModifierExplicitCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const &
-                            imageDrmFormatModifierExplicitCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubresourceLayout *,
-                             seed,
-                             imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageDrmFormatModifierListCreateInfoEXT
   {
     using NativeType = VkImageDrmFormatModifierListCreateInfoEXT;
@@ -37120,29 +35201,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>( this );
     }
 
-    operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint64_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
-             ( pDrmFormatModifiers == rhs.pDrmFormatModifiers );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -37168,25 +35260,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageDrmFormatModifierListCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const &
-                            imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierListCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierListCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageDrmFormatModifierPropertiesEXT
   {
     using NativeType = VkImageDrmFormatModifierPropertiesEXT;
@@ -37218,27 +35291,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT *>( this );
     }
 
-    operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, drmFormatModifier );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default;
 #else
     bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -37262,24 +35345,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageDrmFormatModifierPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const &
-                            imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, imageDrmFormatModifierPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageFormatListCreateInfo
   {
     using NativeType = VkImageFormatListCreateInfo;
@@ -37351,28 +35416,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageFormatListCreateInfo *>( this );
     }
 
-    operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageFormatListCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Format * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, viewFormatCount, pViewFormats );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatListCreateInfo const & ) const = default;
 #else
     bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) &&
-             ( pViewFormats == rhs.pViewFormats );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -37397,25 +35474,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatListCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatListCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatListCreateInfo.viewFormatCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, imageFormatListCreateInfo.pViewFormats );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageFormatProperties2
   {
     using NativeType = VkImageFormatProperties2;
@@ -37444,27 +35502,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageFormatProperties2 *>( this );
     }
 
-    operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageFormatProperties2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ImageFormatProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imageFormatProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatProperties2 const & ) const = default;
 #else
     bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -37488,25 +35558,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageFormatProperties2KHR = ImageFormatProperties2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatProperties2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, imageFormatProperties2.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, imageFormatProperties2.imageFormatProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageMemoryBarrier
   {
     using NativeType = VkImageMemoryBarrier;
@@ -37612,31 +35663,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageMemoryBarrier *>( this );
     }
 
-    operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageMemoryBarrier *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       srcAccessMask,
+                       dstAccessMask,
+                       oldLayout,
+                       newLayout,
+                       srcQueueFamilyIndex,
+                       dstQueueFamilyIndex,
+                       image,
+                       subresourceRange );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageMemoryBarrier const & ) const = default;
 #else
     bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
-             ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) &&
-             ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
-             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) &&
-             ( subresourceRange == rhs.subresourceRange );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -37665,31 +35740,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageMemoryBarrier;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.dstAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.oldLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.newLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.srcQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.dstQueueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier.image );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier.subresourceRange );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageMemoryRequirementsInfo2
   {
     using NativeType = VkImageMemoryRequirementsInfo2;
@@ -37733,27 +35783,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( this );
     }
 
-    operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageMemoryRequirementsInfo2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Image const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, image );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default;
 #else
     bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -37778,24 +35838,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryRequirementsInfo2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryRequirementsInfo2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryRequirementsInfo2.image );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct ImagePipeSurfaceCreateInfoFUCHSIA
   {
@@ -37852,28 +35894,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( this );
     }
 
-    operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA const &,
+               zx_handle_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, imagePipeHandle );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -37897,27 +35951,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImagePipeSurfaceCreateInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &
-                            imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePipeSurfaceCreateInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA, seed, imagePipeSurfaceCreateInfoFUCHSIA.flags );
-    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImagePlaneMemoryRequirementsInfo
@@ -37966,27 +35999,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>( this );
     }
 
-    operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, planeAspect );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default;
 #else
     bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38011,26 +36056,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePlaneMemoryRequirementsInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePlaneMemoryRequirementsInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, imagePlaneMemoryRequirementsInfo.planeAspect );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageResolve
   {
     using NativeType = VkImageResolve;
@@ -38100,28 +36125,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageResolve *>( this );
     }
 
-    operator VkImageResolve &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageResolve &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageResolve *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageResolve const & ) const = default;
 #else
     bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
-             ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38139,25 +36177,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageResolve>::value,
                             "ImageResolve is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageResolve>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.srcSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.srcOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.dstSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.dstOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve.extent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageResolve2KHR
   {
     using NativeType = VkImageResolve2KHR;
@@ -38236,29 +36255,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageResolve2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageResolve2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageResolve2KHR *>( this );
     }
 
-    operator VkImageResolve2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageResolve2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageResolve2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+               VULKAN_HPP_NAMESPACE::Offset3D const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageResolve2KHR const & ) const = default;
 #else
     bool operator==( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
-             ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) &&
-             ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38284,27 +36317,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageResolve2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageResolve2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2KHR const & imageResolve2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageResolve2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageResolve2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.srcSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.srcOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.dstSubresource );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.dstOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve2KHR.extent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageSparseMemoryRequirementsInfo2
   {
     using NativeType = VkImageSparseMemoryRequirementsInfo2;
@@ -38352,27 +36364,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( this );
     }
 
-    operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Image const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, image );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default;
 #else
     bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38397,24 +36419,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const &
-                            imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSparseMemoryRequirementsInfo2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSparseMemoryRequirementsInfo2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageSparseMemoryRequirementsInfo2.image );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageStencilUsageCreateInfo
   {
     using NativeType = VkImageStencilUsageCreateInfo;
@@ -38459,27 +36463,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageStencilUsageCreateInfo *>( this );
     }
 
-    operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageStencilUsageCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stencilUsage );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default;
 #else
     bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38504,24 +36520,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageStencilUsageCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageStencilUsageCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageStencilUsageCreateInfo.stencilUsage );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageSwapchainCreateInfoKHR
   {
     using NativeType = VkImageSwapchainCreateInfoKHR;
@@ -38566,27 +36564,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>( this );
     }
 
-    operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageSwapchainCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SwapchainKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, swapchain );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default;
 #else
     bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38610,24 +36620,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageSwapchainCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSwapchainCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSwapchainCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, imageSwapchainCreateInfoKHR.swapchain );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageViewASTCDecodeModeEXT
   {
     using NativeType = VkImageViewASTCDecodeModeEXT;
@@ -38672,27 +36664,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>( this );
     }
 
-    operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageViewASTCDecodeModeEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Format const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, decodeMode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default;
 #else
     bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38715,24 +36717,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewASTCDecodeModeEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewASTCDecodeModeEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewASTCDecodeModeEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewASTCDecodeModeEXT.decodeMode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageViewAddressPropertiesNVX
   {
     using NativeType = VkImageViewAddressPropertiesNVX;
@@ -38765,28 +36749,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewAddressPropertiesNVX *>( this );
     }
 
-    operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageViewAddressPropertiesNVX *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceAddress const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceAddress, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewAddressPropertiesNVX const & ) const = default;
 #else
     bool operator==( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) &&
-             ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38811,25 +36807,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewAddressPropertiesNVX;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewAddressPropertiesNVX.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, imageViewAddressPropertiesNVX.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, imageViewAddressPropertiesNVX.deviceAddress );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageViewAddressPropertiesNVX.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageViewCreateInfo
   {
     using NativeType = VkImageViewCreateInfo;
@@ -38916,29 +36893,44 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewCreateInfo *>( this );
     }
 
-    operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageViewCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageViewCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageViewType const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+               VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewCreateInfo const & ) const = default;
 #else
     bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) &&
-             ( viewType == rhs.viewType ) && ( format == rhs.format ) && ( components == rhs.components ) &&
-             ( subresourceRange == rhs.subresourceRange );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -38965,29 +36957,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags, seed, imageViewCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageViewCreateInfo.image );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewType, seed, imageViewCreateInfo.viewType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewCreateInfo.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping, seed, imageViewCreateInfo.components );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageViewCreateInfo.subresourceRange );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageViewHandleInfoNVX
   {
     using NativeType = VkImageViewHandleInfoNVX;
@@ -39049,28 +37018,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewHandleInfoNVX *>( this );
     }
 
-    operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageViewHandleInfoNVX *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageView const &,
+               VULKAN_HPP_NAMESPACE::DescriptorType const &,
+               VULKAN_HPP_NAMESPACE::Sampler const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imageView, descriptorType, sampler );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewHandleInfoNVX const & ) const = default;
 #else
     bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
-             ( descriptorType == rhs.descriptorType ) && ( sampler == rhs.sampler );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -39095,26 +37077,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewHandleInfoNVX;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewHandleInfoNVX.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewHandleInfoNVX.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, imageViewHandleInfoNVX.imageView );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, imageViewHandleInfoNVX.descriptorType );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, imageViewHandleInfoNVX.sampler );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageViewMinLodCreateInfoEXT
   {
     using NativeType = VkImageViewMinLodCreateInfoEXT;
@@ -39155,27 +37117,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewMinLodCreateInfoEXT *>( this );
     }
 
-    operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageViewMinLodCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, minLod );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -39199,24 +37171,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewMinLodCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewMinLodCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewMinLodCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( float, seed, imageViewMinLodCreateInfoEXT.minLod );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImageViewUsageCreateInfo
   {
     using NativeType = VkImageViewUsageCreateInfo;
@@ -39260,27 +37214,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewUsageCreateInfo *>( this );
     }
 
-    operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImageViewUsageCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, usage );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewUsageCreateInfo const & ) const = default;
 #else
     bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -39304,24 +37270,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewUsageCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewUsageCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageViewUsageCreateInfo.usage );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct ImportAndroidHardwareBufferInfoANDROID
   {
@@ -39371,27 +37319,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>( this );
     }
 
-    operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, struct AHardwareBuffer * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, buffer );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default;
 #  else
     bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -39415,25 +37373,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportAndroidHardwareBufferInfoANDROID;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const &
-                            importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importAndroidHardwareBufferInfoANDROID.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importAndroidHardwareBufferInfoANDROID.pNext );
-    VULKAN_HPP_HASH_COMBINE( struct AHardwareBuffer *, seed, importAndroidHardwareBufferInfoANDROID.buffer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ImportFenceFdInfoKHR
@@ -39504,28 +37443,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportFenceFdInfoKHR *>( this );
     }
 
-    operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportFenceFdInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Fence const &,
+               VULKAN_HPP_NAMESPACE::FenceImportFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &,
+               int const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fence, flags, handleType, fd );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportFenceFdInfoKHR const & ) const = default;
 #else
     bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) &&
-             ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -39551,28 +37504,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportFenceFdInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceFdInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceFdInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceFdInfoKHR.fence );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceFdInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceFdInfoKHR.handleType );
-    VULKAN_HPP_HASH_COMBINE( int, seed, importFenceFdInfoKHR.fd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ImportFenceWin32HandleInfoKHR
   {
@@ -39654,28 +37585,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( this );
     }
 
-    operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Fence const &,
+               VULKAN_HPP_NAMESPACE::FenceImportFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &,
+               HANDLE const &,
+               LPCWSTR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fence, flags, handleType, handle, name );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) &&
-             ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -39703,30 +37649,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportFenceWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceWin32HandleInfoKHR.fence );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceWin32HandleInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceWin32HandleInfoKHR.handleType );
-    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importFenceWin32HandleInfoKHR.handle );
-    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importFenceWin32HandleInfoKHR.name );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -39785,28 +37707,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA *>( this );
     }
 
-    operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, collection, index );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
-             ( index == rhs.index );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -39830,27 +37764,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryBufferCollectionFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const &
-                            importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryBufferCollectionFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryBufferCollectionFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, importMemoryBufferCollectionFUCHSIA.collection );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, importMemoryBufferCollectionFUCHSIA.index );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImportMemoryFdInfoKHR
@@ -39904,27 +37817,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryFdInfoKHR *>( this );
     }
 
-    operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportMemoryFdInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+               int const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType, fd );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default;
 #else
     bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -39948,26 +37874,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportMemoryFdInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryFdInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryFdInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryFdInfoKHR.handleType );
-    VULKAN_HPP_HASH_COMBINE( int, seed, importMemoryFdInfoKHR.fd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ImportMemoryHostPointerInfoEXT
   {
     using NativeType = VkImportMemoryHostPointerInfoEXT;
@@ -40022,28 +37928,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>( this );
     }
 
-    operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+               void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType, pHostPointer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default;
 #else
     bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
-             ( pHostPointer == rhs.pHostPointer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -40069,26 +37987,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportMemoryHostPointerInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryHostPointerInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryHostPointerInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryHostPointerInfoEXT.handleType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, importMemoryHostPointerInfoEXT.pHostPointer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ImportMemoryWin32HandleInfoKHR
   {
@@ -40152,28 +38050,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>( this );
     }
 
-    operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+               HANDLE const &,
+               LPCWSTR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType, handle, name );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
-             ( handle == rhs.handle ) && ( name == rhs.name );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -40199,28 +38110,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryWin32HandleInfoKHR.handleType );
-    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoKHR.handle );
-    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importMemoryWin32HandleInfoKHR.name );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -40277,28 +38166,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>( this );
     }
 
-    operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &,
+               HANDLE const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType, handle );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default;
 #  else
     bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
-             ( handle == rhs.handle );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -40322,27 +38223,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryWin32HandleInfoNV;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, importMemoryWin32HandleInfoNV.handleType );
-    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoNV.handle );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -40402,28 +38282,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>( this );
     }
 
-    operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+               zx_handle_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType, handle );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
-             ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -40448,27 +38340,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryZirconHandleInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const &
-                            importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryZirconHandleInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryZirconHandleInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryZirconHandleInfoFUCHSIA.handleType );
-    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importMemoryZirconHandleInfoFUCHSIA.handle );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImportSemaphoreFdInfoKHR
@@ -40541,28 +38412,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( this );
     }
 
-    operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportSemaphoreFdInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
+               int const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, flags, handleType, fd );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default;
 #else
     bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -40589,28 +38474,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportSemaphoreFdInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreFdInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreFdInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreFdInfoKHR.semaphore );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreFdInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreFdInfoKHR.handleType );
-    VULKAN_HPP_HASH_COMBINE( int, seed, importSemaphoreFdInfoKHR.fd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ImportSemaphoreWin32HandleInfoKHR
   {
@@ -40693,29 +38556,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( this );
     }
 
-    operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
+               HANDLE const &,
+               LPCWSTR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, flags, handleType, handle, name );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) &&
-             ( name == rhs.name );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -40743,31 +38620,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportSemaphoreWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const &
-                            importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreWin32HandleInfoKHR.semaphore );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreWin32HandleInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreWin32HandleInfoKHR.handleType );
-    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importSemaphoreWin32HandleInfoKHR.handle );
-    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importSemaphoreWin32HandleInfoKHR.name );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -40847,29 +38699,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( this );
     }
 
-    operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
+               zx_handle_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
-             ( memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -40897,31 +38762,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportSemaphoreZirconHandleInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const &
-                            importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreZirconHandleInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreZirconHandleInfoFUCHSIA.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits,
-                             seed,
-                             importSemaphoreZirconHandleInfoFUCHSIA.handleType );
-    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct IndirectCommandsLayoutTokenNV
@@ -41138,34 +38978,65 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNV *>( this );
     }
 
-    operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkIndirectCommandsLayoutTokenNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+               VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::IndexType * const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       tokenType,
+                       stream,
+                       offset,
+                       vertexBindingUnit,
+                       vertexDynamicStride,
+                       pushconstantPipelineLayout,
+                       pushconstantShaderStageFlags,
+                       pushconstantOffset,
+                       pushconstantSize,
+                       indirectStateFlags,
+                       indexTypeCount,
+                       pIndexTypes,
+                       pIndexTypeValues );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default;
 #else
     bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tokenType == rhs.tokenType ) &&
-             ( stream == rhs.stream ) && ( offset == rhs.offset ) && ( vertexBindingUnit == rhs.vertexBindingUnit ) &&
-             ( vertexDynamicStride == rhs.vertexDynamicStride ) &&
-             ( pushconstantPipelineLayout == rhs.pushconstantPipelineLayout ) &&
-             ( pushconstantShaderStageFlags == rhs.pushconstantShaderStageFlags ) &&
-             ( pushconstantOffset == rhs.pushconstantOffset ) && ( pushconstantSize == rhs.pushconstantSize ) &&
-             ( indirectStateFlags == rhs.indirectStateFlags ) && ( indexTypeCount == rhs.indexTypeCount ) &&
-             ( pIndexTypes == rhs.pIndexTypes ) && ( pIndexTypeValues == rhs.pIndexTypeValues );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -41202,40 +39073,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = IndirectCommandsLayoutTokenNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutTokenNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutTokenNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV, seed, indirectCommandsLayoutTokenNV.tokenType );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.stream );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.offset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.vertexBindingUnit );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, indirectCommandsLayoutTokenNV.vertexDynamicStride );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineLayout, seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV, seed, indirectCommandsLayoutTokenNV.indirectStateFlags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.indexTypeCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::IndexType *, seed, indirectCommandsLayoutTokenNV.pIndexTypes );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutTokenNV.pIndexTypeValues );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct IndirectCommandsLayoutCreateInfoNV
   {
     using NativeType = VkIndirectCommandsLayoutCreateInfoNV;
@@ -41365,30 +39202,44 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( this );
     }
 
-    operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV const &,
+               VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default;
 #else
     bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( tokenCount == rhs.tokenCount ) &&
-             ( pTokens == rhs.pTokens ) && ( streamCount == rhs.streamCount ) &&
-             ( pStreamStrides == rhs.pStreamStrides );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -41417,32 +39268,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = IndirectCommandsLayoutCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &
-                            indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV, seed, indirectCommandsLayoutCreateInfoNV.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.tokenCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV *, seed, indirectCommandsLayoutCreateInfoNV.pTokens );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.streamCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct InitializePerformanceApiInfoINTEL
   {
     using NativeType = VkInitializePerformanceApiInfoINTEL;
@@ -41487,27 +39312,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( this );
     }
 
-    operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkInitializePerformanceApiInfoINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pUserData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default;
 #else
     bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -41531,24 +39366,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = InitializePerformanceApiInfoINTEL;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const &
-                            initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, initializePerformanceApiInfoINTEL.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, initializePerformanceApiInfoINTEL.pNext );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, initializePerformanceApiInfoINTEL.pUserData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct InputAttachmentAspectReference
   {
     using NativeType = VkInputAttachmentAspectReference;
@@ -41602,28 +39419,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkInputAttachmentAspectReference *>( this );
     }
 
-    operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkInputAttachmentAspectReference *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ImageAspectFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( subpass, inputAttachmentIndex, aspectMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( InputAttachmentAspectReference const & ) const = default;
 #else
     bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) &&
-             ( aspectMask == rhs.aspectMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -41642,24 +39468,6 @@ namespace VULKAN_HPP_NAMESPACE
     "InputAttachmentAspectReference is not nothrow_move_constructible!" );
   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.subpass );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.inputAttachmentIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, inputAttachmentAspectReference.aspectMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct InstanceCreateInfo
   {
     using NativeType = VkInstanceCreateInfo;
@@ -41783,31 +39591,51 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkInstanceCreateInfo *>( this );
     }
 
-    operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkInstanceCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::InstanceCreateFlags const &,
+               const VULKAN_HPP_NAMESPACE::ApplicationInfo * const &,
+               uint32_t const &,
+               const char * const * const &,
+               uint32_t const &,
+               const char * const * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       pApplicationInfo,
+                       enabledLayerCount,
+                       ppEnabledLayerNames,
+                       enabledExtensionCount,
+                       ppEnabledExtensionNames );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( InstanceCreateInfo const & ) const = default;
 #else
     bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pApplicationInfo == rhs.pApplicationInfo ) && ( enabledLayerCount == rhs.enabledLayerCount ) &&
-             ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) &&
-             ( enabledExtensionCount == rhs.enabledExtensionCount ) &&
-             ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -41834,29 +39662,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = InstanceCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, instanceCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, instanceCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::InstanceCreateFlags, seed, instanceCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ApplicationInfo *, seed, instanceCreateInfo.pApplicationInfo );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledLayerCount );
-    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledLayerNames );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledExtensionCount );
-    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledExtensionNames );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct LayerProperties
   {
     using NativeType = VkLayerProperties;
@@ -41888,28 +39693,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkLayerProperties *>( this );
     }
 
-    operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkLayerProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( layerName, specVersion, implementationVersion, description );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( LayerProperties const & ) const = default;
 #else
     bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( layerName == rhs.layerName ) && ( specVersion == rhs.specVersion ) &&
-             ( implementationVersion == rhs.implementationVersion ) && ( description == rhs.description );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -41926,30 +39743,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LayerProperties>::value,
                             "LayerProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::LayerProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.layerName[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.specVersion );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.implementationVersion );
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.description[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_MACOS_MVK )
   struct MacOSSurfaceCreateInfoMVK
   {
@@ -42002,27 +39795,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( this );
     }
 
-    operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK const &,
+               const void * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pView );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default;
 #  else
     bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -42045,26 +39851,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MacOSSurfaceCreateInfoMVK;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, macOSSurfaceCreateInfoMVK.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK, seed, macOSSurfaceCreateInfoMVK.flags );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pView );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
   struct MappedMemoryRange
@@ -42126,28 +39912,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMappedMemoryRange *>( this );
     }
 
-    operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMappedMemoryRange *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memory, offset, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MappedMemoryRange const & ) const = default;
 #else
     bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) &&
-             ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -42171,25 +39970,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MappedMemoryRange;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mappedMemoryRange.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, mappedMemoryRange.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, mappedMemoryRange.memory );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryAllocateFlagsInfo
   {
     using NativeType = VkMemoryAllocateFlagsInfo;
@@ -42240,28 +40020,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryAllocateFlagsInfo *>( this );
     }
 
-    operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryAllocateFlagsInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::MemoryAllocateFlags const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, deviceMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default;
 #else
     bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( deviceMask == rhs.deviceMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -42286,25 +40078,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateFlagsInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateFlagsInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryAllocateFlags, seed, memoryAllocateFlagsInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateFlagsInfo.deviceMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryAllocateInfo
   {
     using NativeType = VkMemoryAllocateInfo;
@@ -42355,28 +40128,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryAllocateInfo *>( this );
     }
 
-    operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryAllocateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, allocationSize, memoryTypeIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryAllocateInfo const & ) const = default;
 #else
     bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) &&
-             ( memoryTypeIndex == rhs.memoryTypeIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -42399,25 +40184,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryAllocateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryAllocateInfo.allocationSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateInfo.memoryTypeIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryBarrier
   {
     using NativeType = VkMemoryBarrier;
@@ -42469,28 +40235,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryBarrier *>( this );
     }
 
-    operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryBarrier *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcAccessMask, dstAccessMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryBarrier const & ) const = default;
 #else
     bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
-             ( dstAccessMask == rhs.dstAccessMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -42513,24 +40291,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryBarrier;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryBarrier>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.dstAccessMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryDedicatedAllocateInfo
   {
     using NativeType = VkMemoryDedicatedAllocateInfo;
@@ -42583,27 +40343,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>( this );
     }
 
-    operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryDedicatedAllocateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, image, buffer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default;
 #else
     bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -42629,25 +40402,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedAllocateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryDedicatedAllocateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, memoryDedicatedAllocateInfo.image );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, memoryDedicatedAllocateInfo.buffer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryDedicatedRequirements
   {
     using NativeType = VkMemoryDedicatedRequirements;
@@ -42679,29 +40433,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryDedicatedRequirements *>( this );
     }
 
-    operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryDedicatedRequirements *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryDedicatedRequirements const & ) const = default;
 #else
     bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) &&
-             ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -42727,27 +40492,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedRequirements.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryDedicatedRequirements.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.prefersDedicatedAllocation );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.requiresDedicatedAllocation );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryFdPropertiesKHR
   {
     using NativeType = VkMemoryFdPropertiesKHR;
@@ -42775,27 +40519,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryFdPropertiesKHR *>( this );
     }
 
-    operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryFdPropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryTypeBits );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryFdPropertiesKHR const & ) const = default;
 #else
     bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -42817,24 +40571,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryFdPropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryFdPropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryFdPropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryFdPropertiesKHR.memoryTypeBits );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct MemoryGetAndroidHardwareBufferInfoANDROID
   {
@@ -42886,27 +40622,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( this );
     }
 
-    operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memory );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default;
 #  else
     bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -42930,27 +40678,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryGetAndroidHardwareBufferInfoANDROID;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const &
-                            memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetAndroidHardwareBufferInfoANDROID.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetAndroidHardwareBufferInfoANDROID.memory );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct MemoryGetFdInfoKHR
@@ -43006,28 +40733,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetFdInfoKHR *>( this );
     }
 
-    operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryGetFdInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memory, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetFdInfoKHR const & ) const = default;
 #else
     bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43051,26 +40790,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryGetFdInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetFdInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetFdInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetFdInfoKHR.memory );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetFdInfoKHR.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryGetRemoteAddressInfoNV
   {
     using NativeType = VkMemoryGetRemoteAddressInfoNV;
@@ -43125,28 +40844,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( this );
     }
 
-    operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryGetRemoteAddressInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memory, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default;
 #else
     bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43172,26 +40903,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryGetRemoteAddressInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetRemoteAddressInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetRemoteAddressInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetRemoteAddressInfoNV.memory );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetRemoteAddressInfoNV.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct MemoryGetWin32HandleInfoKHR
   {
@@ -43247,28 +40958,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( this );
     }
 
-    operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memory, handleType );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -43293,27 +41016,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryGetWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetWin32HandleInfoKHR.memory );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetWin32HandleInfoKHR.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -43372,28 +41074,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( this );
     }
 
-    operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memory, handleType );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -43418,28 +41132,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryGetZirconHandleInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetZirconHandleInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetZirconHandleInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetZirconHandleInfoFUCHSIA.memory );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetZirconHandleInfoFUCHSIA.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct MemoryHeap
@@ -43468,27 +41160,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryHeap *>( this );
     }
 
-    operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryHeap *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &, VULKAN_HPP_NAMESPACE::MemoryHeapFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( size, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryHeap const & ) const = default;
 #else
     bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( size == rhs.size ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43503,22 +41205,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryHeap>::value,
                             "MemoryHeap is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryHeap>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryHeap.size );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeapFlags, seed, memoryHeap.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryHostPointerPropertiesEXT
   {
     using NativeType = VkMemoryHostPointerPropertiesEXT;
@@ -43548,27 +41234,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT *>( this );
     }
 
-    operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryTypeBits );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default;
 #else
     bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43592,24 +41288,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryHostPointerPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryHostPointerPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryHostPointerPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryHostPointerPropertiesEXT.memoryTypeBits );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryOpaqueCaptureAddressAllocateInfo
   {
     using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo;
@@ -43658,27 +41336,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo *>( this );
     }
 
-    operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, opaqueCaptureAddress );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default;
 #else
     bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43704,24 +41392,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const &
-                            memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryOpaqueCaptureAddressAllocateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryOpaqueCaptureAddressAllocateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryPriorityAllocateInfoEXT
   {
     using NativeType = VkMemoryPriorityAllocateInfoEXT;
@@ -43765,27 +41435,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>( this );
     }
 
-    operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, priority );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default;
 #else
     bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43809,24 +41489,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryPriorityAllocateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryPriorityAllocateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryPriorityAllocateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( float, seed, memoryPriorityAllocateInfoEXT.priority );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryRequirements
   {
     using NativeType = VkMemoryRequirements;
@@ -43855,27 +41517,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryRequirements *>( this );
     }
 
-    operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryRequirements *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &, VULKAN_HPP_NAMESPACE::DeviceSize const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( size, alignment, memoryTypeBits );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryRequirements const & ) const = default;
 #else
     bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43891,24 +41563,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryRequirements>::value,
                             "MemoryRequirements is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryRequirements>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.size );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.alignment );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryRequirements.memoryTypeBits );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryRequirements2
   {
     using NativeType = VkMemoryRequirements2;
@@ -43937,27 +41591,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryRequirements2 *>( this );
     }
 
-    operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryRequirements2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::MemoryRequirements const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryRequirements );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryRequirements2 const & ) const = default;
 #else
     bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -43980,24 +41646,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryRequirements2KHR = MemoryRequirements2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryRequirements2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryRequirements2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryRequirements, seed, memoryRequirements2.memoryRequirements );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MemoryType
   {
     using NativeType = VkMemoryType;
@@ -44024,27 +41672,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryType *>( this );
     }
 
-    operator VkMemoryType &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryType &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryType *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::MemoryPropertyFlags const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( propertyFlags, heapIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryType const & ) const = default;
 #else
     bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -44059,22 +41717,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryType>::value,
                             "MemoryType is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryType>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryPropertyFlags, seed, memoryType.propertyFlags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryType.heapIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct MemoryWin32HandlePropertiesKHR
   {
@@ -44105,27 +41747,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR *>( this );
     }
 
-    operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryTypeBits );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default;
 #  else
     bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -44148,25 +41800,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryWin32HandlePropertiesKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryWin32HandlePropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryWin32HandlePropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryWin32HandlePropertiesKHR.memoryTypeBits );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -44201,27 +41834,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryZirconHandlePropertiesFUCHSIA *>( this );
     }
 
-    operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryTypeBits );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default;
 #  else
     bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -44244,25 +41887,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryZirconHandlePropertiesFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const &
-                            memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryZirconHandlePropertiesFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryZirconHandlePropertiesFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_METAL_EXT )
@@ -44317,27 +41941,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( this );
     }
 
-    operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMetalSurfaceCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT const &,
+               const CAMetalLayer * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pLayer );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -44360,26 +41997,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MetalSurfaceCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, metalSurfaceCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, metalSurfaceCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT, seed, metalSurfaceCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( const CAMetalLayer *, seed, metalSurfaceCreateInfoEXT.pLayer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
   struct MultiDrawIndexedInfoEXT
@@ -44430,28 +42047,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( this );
     }
 
-    operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMultiDrawIndexedInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( firstIndex, indexCount, vertexOffset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default;
 #else
     bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) &&
-             ( vertexOffset == rhs.vertexOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -44468,24 +42094,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>::value,
                             "MultiDrawIndexedInfoEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.firstIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.indexCount );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, multiDrawIndexedInfoEXT.vertexOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MultiDrawInfoEXT
   {
     using NativeType = VkMultiDrawInfoEXT;
@@ -44525,27 +42133,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMultiDrawInfoEXT *>( this );
     }
 
-    operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMultiDrawInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( firstVertex, vertexCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultiDrawInfoEXT const & ) const = default;
 #else
     bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -44560,22 +42178,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>::value,
                             "MultiDrawInfoEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.firstVertex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.vertexCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MultisamplePropertiesEXT
   {
     using NativeType = VkMultisamplePropertiesEXT;
@@ -44604,28 +42206,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMultisamplePropertiesEXT *>( this );
     }
 
-    operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMultisamplePropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxSampleLocationGridSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultisamplePropertiesEXT const & ) const = default;
 #else
     bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -44648,24 +42259,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MultisamplePropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multisamplePropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, multisamplePropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, multisamplePropertiesEXT.maxSampleLocationGridSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MultiviewPerViewAttributesInfoNVX
   {
     using NativeType = VkMultiviewPerViewAttributesInfoNVX;
@@ -44721,28 +42314,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX *>( this );
     }
 
-    operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default;
 #else
     bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) &&
-             ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -44767,26 +42372,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MultiviewPerViewAttributesInfoNVX;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const &
-                            multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multiviewPerViewAttributesInfoNVX.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, multiviewPerViewAttributesInfoNVX.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MutableDescriptorTypeListVALVE
   {
     using NativeType = VkMutableDescriptorTypeListVALVE;
@@ -44852,27 +42437,37 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMutableDescriptorTypeListVALVE *>( this );
     }
 
-    operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMutableDescriptorTypeListVALVE *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::DescriptorType * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( descriptorTypeCount, pDescriptorTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default;
 #else
     bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -44889,24 +42484,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE>::value,
     "MutableDescriptorTypeListVALVE is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const & mutableDescriptorTypeListVALVE )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeListVALVE.descriptorTypeCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DescriptorType *, seed, mutableDescriptorTypeListVALVE.pDescriptorTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct MutableDescriptorTypeCreateInfoVALVE
   {
     using NativeType = VkMutableDescriptorTypeCreateInfoVALVE;
@@ -44984,29 +42561,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE *>( this );
     }
 
-    operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default;
 #else
     bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) &&
-             ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45031,27 +42619,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MutableDescriptorTypeCreateInfoVALVE;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const &
-                            mutableDescriptorTypeCreateInfoVALVE ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mutableDescriptorTypeCreateInfoVALVE.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, mutableDescriptorTypeCreateInfoVALVE.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeCreateInfoVALVE.mutableDescriptorTypeListCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE *,
-                             seed,
-                             mutableDescriptorTypeCreateInfoVALVE.pMutableDescriptorTypeLists );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PastPresentationTimingGOOGLE
   {
     using NativeType = VkPastPresentationTimingGOOGLE;
@@ -45085,29 +42652,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPastPresentationTimingGOOGLE *>( this );
     }
 
-    operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPastPresentationTimingGOOGLE *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint64_t const &, uint64_t const &, uint64_t const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default;
 #else
     bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) &&
-             ( actualPresentTime == rhs.actualPresentTime ) && ( earliestPresentTime == rhs.earliestPresentTime ) &&
-             ( presentMargin == rhs.presentMargin );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45127,26 +42702,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
     "PastPresentationTimingGOOGLE is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pastPresentationTimingGOOGLE.presentID );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.desiredPresentTime );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.actualPresentTime );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.earliestPresentTime );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.presentMargin );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PerformanceConfigurationAcquireInfoINTEL
   {
     using NativeType = VkPerformanceConfigurationAcquireInfoINTEL;
@@ -45198,27 +42753,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( this );
     }
 
-    operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, type );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45244,26 +42811,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceConfigurationAcquireInfoINTEL;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &
-                            performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, performanceConfigurationAcquireInfoINTEL.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceConfigurationAcquireInfoINTEL.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL, seed, performanceConfigurationAcquireInfoINTEL.type );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PerformanceCounterDescriptionKHR
   {
     using NativeType = VkPerformanceCounterDescriptionKHR;
@@ -45300,28 +42847,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceCounterDescriptionKHR *>( this );
     }
 
-    operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, name, category, description );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceCounterDescriptionKHR const & ) const = default;
 #else
     bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) &&
-             ( category == rhs.category ) && ( description == rhs.description );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45348,38 +42909,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceCounterDescriptionKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterDescriptionKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterDescriptionKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR, seed, performanceCounterDescriptionKHR.flags );
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.name[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.category[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.description[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PerformanceCounterKHR
   {
     using NativeType = VkPerformanceCounterKHR;
@@ -45416,28 +42945,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceCounterKHR *>( this );
     }
 
-    operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceCounterKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR const &,
+               VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR const &,
+               VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, unit, scope, storage, uuid );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceCounterKHR const & ) const = default;
 #else
     bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) &&
-             ( storage == rhs.storage ) && ( uuid == rhs.uuid );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45464,30 +43007,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceCounterKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR, seed, performanceCounterKHR.unit );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR, seed, performanceCounterKHR.scope );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR, seed, performanceCounterKHR.storage );
-    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, performanceCounterKHR.uuid[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   union PerformanceCounterResultKHR
   {
     using NativeType = VkPerformanceCounterResultKHR;
@@ -45602,27 +43121,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( this );
     }
 
-    operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceMarkerInfoINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, marker );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45645,24 +43174,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceMarkerInfoINTEL;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceMarkerInfoINTEL.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceMarkerInfoINTEL.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceMarkerInfoINTEL.marker );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PerformanceOverrideInfoINTEL
   {
     using NativeType = VkPerformanceOverrideInfoINTEL;
@@ -45725,28 +43236,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( this );
     }
 
-    operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceOverrideInfoINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, type, enable, parameter );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) &&
-             ( parameter == rhs.parameter );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45773,27 +43297,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceOverrideInfoINTEL;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceOverrideInfoINTEL.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceOverrideInfoINTEL.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL, seed, performanceOverrideInfoINTEL.type );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, performanceOverrideInfoINTEL.enable );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceOverrideInfoINTEL.parameter );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PerformanceQuerySubmitInfoKHR
   {
     using NativeType = VkPerformanceQuerySubmitInfoKHR;
@@ -45838,27 +43341,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR *>( this );
     }
 
-    operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceQuerySubmitInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, counterPassIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default;
 #else
     bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45882,24 +43395,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceQuerySubmitInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceQuerySubmitInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceQuerySubmitInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceQuerySubmitInfoKHR.counterPassIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PerformanceStreamMarkerInfoINTEL
   {
     using NativeType = VkPerformanceStreamMarkerInfoINTEL;
@@ -45943,27 +43438,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( this );
     }
 
-    operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, marker );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -45987,25 +43492,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceStreamMarkerInfoINTEL;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceStreamMarkerInfoINTEL.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceStreamMarkerInfoINTEL.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceStreamMarkerInfoINTEL.marker );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   union PerformanceValueDataINTEL
   {
     using NativeType = VkPerformanceValueDataINTEL;
@@ -46121,16 +43607,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceValueINTEL *>( this );
     }
 
-    operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPerformanceValueINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL const &,
+               VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( type, data );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32;
     VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data = {};
@@ -46216,31 +43713,47 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>( this );
     }
 
-    operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       storageBuffer16BitAccess,
+                       uniformAndStorageBuffer16BitAccess,
+                       storagePushConstant16,
+                       storageInputOutput16 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevice16BitStorageFeatures const & ) const = default;
 #else
-    bool         operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) &&
-             ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) &&
-             ( storagePushConstant16 == rhs.storagePushConstant16 ) &&
-             ( storageInputOutput16 == rhs.storageInputOutput16 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -46268,31 +43781,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const &
-                            physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice16BitStorageFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice16BitStorageFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storagePushConstant16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageInputOutput16 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevice4444FormatsFeaturesEXT
   {
     using NativeType = VkPhysicalDevice4444FormatsFeaturesEXT;
@@ -46349,28 +43837,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) &&
-             ( formatA4B4G4R4 == rhs.formatA4B4G4R4 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -46395,25 +43895,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevice4444FormatsFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const &
-                            physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice4444FormatsFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice4444FormatsFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevice8BitStorageFeatures
   {
     using NativeType = VkPhysicalDevice8BitStorageFeatures;
@@ -46478,30 +43959,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>( this );
     }
 
-    operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevice8BitStorageFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) &&
-             ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) &&
-             ( storagePushConstant8 == rhs.storagePushConstant8 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -46528,29 +44020,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const &
-                            physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice8BitStorageFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice8BitStorageFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storagePushConstant8 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceASTCDecodeFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceASTCDecodeFeaturesEXT;
@@ -46598,28 +44067,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, decodeModeSharedExponent );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( decodeModeSharedExponent == rhs.decodeModeSharedExponent );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -46643,25 +44121,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceASTCDecodeFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const &
-                            physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceASTCDecodeFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceASTCDecodeFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceAccelerationStructureFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceAccelerationStructureFeaturesKHR;
@@ -46749,33 +44208,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       accelerationStructure,
+                       accelerationStructureCaptureReplay,
+                       accelerationStructureIndirectBuild,
+                       accelerationStructureHostCommands,
+                       descriptorBindingAccelerationStructureUpdateAfterBind );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( accelerationStructure == rhs.accelerationStructure ) &&
-             ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) &&
-             ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) &&
-             ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) &&
-             ( descriptorBindingAccelerationStructureUpdateAfterBind ==
-               rhs.descriptorBindingAccelerationStructureUpdateAfterBind );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -46804,39 +44279,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceAccelerationStructureFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const &
-                            physicalDeviceAccelerationStructureFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructureFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceAccelerationStructurePropertiesKHR
   {
     using NativeType = VkPhysicalDeviceAccelerationStructurePropertiesKHR;
@@ -46886,35 +44328,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint64_t const &,
+               uint64_t const &,
+               uint64_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       maxGeometryCount,
+                       maxInstanceCount,
+                       maxPrimitiveCount,
+                       maxPerStageDescriptorAccelerationStructures,
+                       maxPerStageDescriptorUpdateAfterBindAccelerationStructures,
+                       maxDescriptorSetAccelerationStructures,
+                       maxDescriptorSetUpdateAfterBindAccelerationStructures,
+                       minAccelerationStructureScratchOffsetAlignment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) &&
-             ( maxInstanceCount == rhs.maxInstanceCount ) && ( maxPrimitiveCount == rhs.maxPrimitiveCount ) &&
-             ( maxPerStageDescriptorAccelerationStructures == rhs.maxPerStageDescriptorAccelerationStructures ) &&
-             ( maxPerStageDescriptorUpdateAfterBindAccelerationStructures ==
-               rhs.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ) &&
-             ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ) &&
-             ( maxDescriptorSetUpdateAfterBindAccelerationStructures ==
-               rhs.maxDescriptorSetUpdateAfterBindAccelerationStructures ) &&
-             ( minAccelerationStructureScratchOffsetAlignment == rhs.minAccelerationStructureScratchOffsetAlignment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -46946,41 +44408,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceAccelerationStructurePropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const &
-                            physicalDeviceAccelerationStructurePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructurePropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t,
-      seed,
-      physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t,
-      seed,
-      physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
@@ -47031,28 +44458,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, advancedBlendCoherentOperations );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47077,27 +44513,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const &
-                            physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
@@ -47143,33 +44558,51 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       advancedBlendMaxColorAttachments,
+                       advancedBlendIndependentBlend,
+                       advancedBlendNonPremultipliedSrcColor,
+                       advancedBlendNonPremultipliedDstColor,
+                       advancedBlendCorrelatedOverlap,
+                       advancedBlendAllOperations );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) &&
-             ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) &&
-             ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) &&
-             ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) &&
-             ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) &&
-             ( advancedBlendAllOperations == rhs.advancedBlendAllOperations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47199,41 +44632,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const &
-                            physicalDeviceBlendOperationAdvancedPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceBorderColorSwizzleFeaturesEXT;
@@ -47292,28 +44690,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) &&
-             ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47339,28 +44749,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const &
-                            physicalDeviceBorderColorSwizzleFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceBufferDeviceAddressFeatures
   {
     using NativeType = VkPhysicalDeviceBufferDeviceAddressFeatures;
@@ -47428,29 +44816,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
-             ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
-             ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47478,30 +44879,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const &
-                            physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
@@ -47569,29 +44946,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
-             ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
-             ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47619,31 +45009,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const &
-                            physicalDeviceBufferDeviceAddressFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceCoherentMemoryFeaturesAMD
   {
     using NativeType = VkPhysicalDeviceCoherentMemoryFeaturesAMD;
@@ -47692,27 +45057,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>( this );
     }
 
-    operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceCoherentMemory );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47737,25 +45112,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCoherentMemoryFeaturesAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const &
-                            physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoherentMemoryFeaturesAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceColorWriteEnableFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceColorWriteEnableFeaturesEXT;
@@ -47804,27 +45160,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, colorWriteEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47849,26 +45215,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceColorWriteEnableFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const &
-                            physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceColorWriteEnableFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
   {
     using NativeType = VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
@@ -47928,29 +45274,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) &&
-             ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -47976,30 +45333,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const &
-                            physicalDeviceComputeShaderDerivativesFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceConditionalRenderingFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceConditionalRenderingFeaturesEXT;
@@ -48059,28 +45392,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) &&
-             ( inheritedConditionalRendering == rhs.inheritedConditionalRendering );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48106,28 +45451,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceConditionalRenderingFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const &
-                            physicalDeviceConditionalRenderingFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConditionalRenderingFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceConservativeRasterizationPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
@@ -48179,36 +45502,57 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               float const &,
+               float const &,
+               float const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       primitiveOverestimationSize,
+                       maxExtraPrimitiveOverestimationSize,
+                       extraPrimitiveOverestimationSizeGranularity,
+                       primitiveUnderestimation,
+                       conservativePointAndLineRasterization,
+                       degenerateTrianglesRasterized,
+                       degenerateLinesRasterized,
+                       fullyCoveredFragmentShaderInputVariable,
+                       conservativeRasterizationPostDepthCoverage );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) &&
-             ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) &&
-             ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) &&
-             ( primitiveUnderestimation == rhs.primitiveUnderestimation ) &&
-             ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) &&
-             ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) &&
-             ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) &&
-             ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) &&
-             ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48241,51 +45585,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const &
-                            physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize );
-    VULKAN_HPP_HASH_COMBINE(
-      float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize );
-    VULKAN_HPP_HASH_COMBINE(
-      float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceCooperativeMatrixFeaturesNV
   {
     using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesNV;
@@ -48344,28 +45643,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) &&
-             ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48391,29 +45702,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCooperativeMatrixFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const &
-                            physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceCooperativeMatrixPropertiesNV
   {
     using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesNV;
@@ -48448,28 +45736,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>( this );
     }
 
-    operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ShaderStageFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, cooperativeMatrixSupportedStages );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48494,27 +45792,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCooperativeMatrixPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const &
-                            physicalDeviceCooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags,
-                             seed,
-                             physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceCornerSampledImageFeaturesNV
   {
     using NativeType = VkPhysicalDeviceCornerSampledImageFeaturesNV;
@@ -48564,27 +45841,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, cornerSampledImage );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48609,26 +45896,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCornerSampledImageFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const &
-                            physicalDeviceCornerSampledImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCornerSampledImageFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCornerSampledImageFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceCoverageReductionModeFeaturesNV
   {
     using NativeType = VkPhysicalDeviceCoverageReductionModeFeaturesNV;
@@ -48679,27 +45946,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, coverageReductionMode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48724,26 +46001,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCoverageReductionModeFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const &
-                            physicalDeviceCoverageReductionModeFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoverageReductionModeFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceCustomBorderColorFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceCustomBorderColorFeaturesEXT;
@@ -48802,28 +46059,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) &&
-             ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48849,28 +46118,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCustomBorderColorFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const &
-                            physicalDeviceCustomBorderColorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceCustomBorderColorPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceCustomBorderColorPropertiesEXT;
@@ -48905,28 +46152,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxCustomBorderColorSamplers );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -48951,26 +46207,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCustomBorderColorPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const &
-                            physicalDeviceCustomBorderColorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
   {
     using NativeType = VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
@@ -49023,28 +46259,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, dedicatedAllocationImageAliasing );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -49071,28 +46316,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &
-                            physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDepthClipControlFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT;
@@ -49141,27 +46364,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, depthClipControl );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -49186,26 +46419,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDepthClipControlFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const &
-                            physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipControlFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipControlFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDepthClipEnableFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceDepthClipEnableFeaturesEXT;
@@ -49255,27 +46468,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, depthClipEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -49300,26 +46523,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDepthClipEnableFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const &
-                            physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipEnableFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDepthStencilResolveProperties
   {
     using NativeType = VkPhysicalDeviceDepthStencilResolveProperties;
@@ -49360,31 +46563,47 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties *>( this );
     }
 
-    operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+               VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       supportedDepthResolveModes,
+                       supportedStencilResolveModes,
+                       independentResolveNone,
+                       independentResolve );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) &&
-             ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) &&
-             ( independentResolveNone == rhs.independentResolveNone ) &&
-             ( independentResolve == rhs.independentResolve );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -49413,34 +46632,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const &
-                            physicalDeviceDepthStencilResolveProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthStencilResolveProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthStencilResolveProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags,
-                             seed,
-                             physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags,
-                             seed,
-                             physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolve );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDescriptorIndexingFeatures
   {
     using NativeType = VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -49665,51 +46856,79 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       shaderInputAttachmentArrayDynamicIndexing,
+                       shaderUniformTexelBufferArrayDynamicIndexing,
+                       shaderStorageTexelBufferArrayDynamicIndexing,
+                       shaderUniformBufferArrayNonUniformIndexing,
+                       shaderSampledImageArrayNonUniformIndexing,
+                       shaderStorageBufferArrayNonUniformIndexing,
+                       shaderStorageImageArrayNonUniformIndexing,
+                       shaderInputAttachmentArrayNonUniformIndexing,
+                       shaderUniformTexelBufferArrayNonUniformIndexing,
+                       shaderStorageTexelBufferArrayNonUniformIndexing,
+                       descriptorBindingUniformBufferUpdateAfterBind,
+                       descriptorBindingSampledImageUpdateAfterBind,
+                       descriptorBindingStorageImageUpdateAfterBind,
+                       descriptorBindingStorageBufferUpdateAfterBind,
+                       descriptorBindingUniformTexelBufferUpdateAfterBind,
+                       descriptorBindingStorageTexelBufferUpdateAfterBind,
+                       descriptorBindingUpdateUnusedWhilePending,
+                       descriptorBindingPartiallyBound,
+                       descriptorBindingVariableDescriptorCount,
+                       runtimeDescriptorArray );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) &&
-             ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) &&
-             ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) &&
-             ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) &&
-             ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) &&
-             ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) &&
-             ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) &&
-             ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) &&
-             ( shaderUniformTexelBufferArrayNonUniformIndexing ==
-               rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) &&
-             ( shaderStorageTexelBufferArrayNonUniformIndexing ==
-               rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) &&
-             ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) &&
-             ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) &&
-             ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) &&
-             ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) &&
-             ( descriptorBindingUniformTexelBufferUpdateAfterBind ==
-               rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) &&
-             ( descriptorBindingStorageTexelBufferUpdateAfterBind ==
-               rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) &&
-             ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) &&
-             ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) &&
-             ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) &&
-             ( runtimeDescriptorArray == rhs.runtimeDescriptorArray );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -49754,84 +46973,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const &
-                            physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDescriptorIndexingProperties
   {
     using NativeType = VkPhysicalDeviceDescriptorIndexingProperties;
@@ -49910,62 +47051,85 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties *>( this );
     }
 
-    operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       maxUpdateAfterBindDescriptorsInAllPools,
+                       shaderUniformBufferArrayNonUniformIndexingNative,
+                       shaderSampledImageArrayNonUniformIndexingNative,
+                       shaderStorageBufferArrayNonUniformIndexingNative,
+                       shaderStorageImageArrayNonUniformIndexingNative,
+                       shaderInputAttachmentArrayNonUniformIndexingNative,
+                       robustBufferAccessUpdateAfterBind,
+                       quadDivergentImplicitLod,
+                       maxPerStageDescriptorUpdateAfterBindSamplers,
+                       maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+                       maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+                       maxPerStageDescriptorUpdateAfterBindSampledImages,
+                       maxPerStageDescriptorUpdateAfterBindStorageImages,
+                       maxPerStageDescriptorUpdateAfterBindInputAttachments,
+                       maxPerStageUpdateAfterBindResources,
+                       maxDescriptorSetUpdateAfterBindSamplers,
+                       maxDescriptorSetUpdateAfterBindUniformBuffers,
+                       maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+                       maxDescriptorSetUpdateAfterBindStorageBuffers,
+                       maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+                       maxDescriptorSetUpdateAfterBindSampledImages,
+                       maxDescriptorSetUpdateAfterBindStorageImages,
+                       maxDescriptorSetUpdateAfterBindInputAttachments );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) &&
-             ( shaderUniformBufferArrayNonUniformIndexingNative ==
-               rhs.shaderUniformBufferArrayNonUniformIndexingNative ) &&
-             ( shaderSampledImageArrayNonUniformIndexingNative ==
-               rhs.shaderSampledImageArrayNonUniformIndexingNative ) &&
-             ( shaderStorageBufferArrayNonUniformIndexingNative ==
-               rhs.shaderStorageBufferArrayNonUniformIndexingNative ) &&
-             ( shaderStorageImageArrayNonUniformIndexingNative ==
-               rhs.shaderStorageImageArrayNonUniformIndexingNative ) &&
-             ( shaderInputAttachmentArrayNonUniformIndexingNative ==
-               rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) &&
-             ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) &&
-             ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) &&
-             ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) &&
-             ( maxPerStageDescriptorUpdateAfterBindUniformBuffers ==
-               rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) &&
-             ( maxPerStageDescriptorUpdateAfterBindStorageBuffers ==
-               rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) &&
-             ( maxPerStageDescriptorUpdateAfterBindSampledImages ==
-               rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) &&
-             ( maxPerStageDescriptorUpdateAfterBindStorageImages ==
-               rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) &&
-             ( maxPerStageDescriptorUpdateAfterBindInputAttachments ==
-               rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) &&
-             ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) &&
-             ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) &&
-             ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) &&
-             ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ==
-               rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) &&
-             ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) &&
-             ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ==
-               rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) &&
-             ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) &&
-             ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) &&
-             ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50013,81 +47177,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const &
-                            physicalDeviceDescriptorIndexingProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
   {
     using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
@@ -50138,28 +47227,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceGeneratedCommands );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( deviceGeneratedCommands == rhs.deviceGeneratedCommands );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50184,26 +47282,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &
-                            physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
   {
     using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
@@ -50255,36 +47333,57 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>( this );
     }
 
-    operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       maxGraphicsShaderGroupCount,
+                       maxIndirectSequenceCount,
+                       maxIndirectCommandsTokenCount,
+                       maxIndirectCommandsStreamCount,
+                       maxIndirectCommandsTokenOffset,
+                       maxIndirectCommandsStreamStride,
+                       minSequencesCountBufferOffsetAlignment,
+                       minSequencesIndexBufferOffsetAlignment,
+                       minIndirectCommandsBufferOffsetAlignment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxGraphicsShaderGroupCount == rhs.maxGraphicsShaderGroupCount ) &&
-             ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) &&
-             ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) &&
-             ( maxIndirectCommandsStreamCount == rhs.maxIndirectCommandsStreamCount ) &&
-             ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) &&
-             ( maxIndirectCommandsStreamStride == rhs.maxIndirectCommandsStreamStride ) &&
-             ( minSequencesCountBufferOffsetAlignment == rhs.minSequencesCountBufferOffsetAlignment ) &&
-             ( minSequencesIndexBufferOffsetAlignment == rhs.minSequencesIndexBufferOffsetAlignment ) &&
-             ( minIndirectCommandsBufferOffsetAlignment == rhs.minIndirectCommandsBufferOffsetAlignment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50317,42 +47416,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &
-                            physicalDeviceDeviceGeneratedCommandsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;
@@ -50402,27 +47465,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceMemoryReport );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50447,26 +47520,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const &
-                            physicalDeviceDeviceMemoryReportFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDiagnosticsConfigFeaturesNV
   {
     using NativeType = VkPhysicalDeviceDiagnosticsConfigFeaturesNV;
@@ -50516,27 +47569,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, diagnosticsConfig );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50561,26 +47624,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const &
-                            physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDiscardRectanglePropertiesEXT
   {
     using NativeType = VkPhysicalDeviceDiscardRectanglePropertiesEXT;
@@ -50615,27 +47658,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxDiscardRectangles );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50660,25 +47713,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDiscardRectanglePropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const &
-                            physicalDeviceDiscardRectanglePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiscardRectanglePropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDriverProperties
   {
     using NativeType = VkPhysicalDeviceDriverProperties;
@@ -50715,29 +47749,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDriverProperties *>( this );
     }
 
-    operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDriverProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DriverId const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ConformanceVersion const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDriverProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) &&
-             ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) &&
-             ( conformanceVersion == rhs.conformanceVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50765,34 +47812,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDriverProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDriverProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceDriverProperties.driverID );
-    for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverName[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverInfo[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceDriverProperties.conformanceVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDrmPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceDrmPropertiesEXT;
@@ -50832,30 +47851,44 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               int64_t const &,
+               int64_t const &,
+               int64_t const &,
+               int64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) &&
-             ( hasRender == rhs.hasRender ) && ( primaryMajor == rhs.primaryMajor ) &&
-             ( primaryMinor == rhs.primaryMinor ) && ( renderMajor == rhs.renderMajor ) &&
-             ( renderMinor == rhs.renderMinor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -50884,29 +47917,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDrmPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDrmPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDrmPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasPrimary );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasRender );
-    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMajor );
-    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMinor );
-    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMajor );
-    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMinor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceDynamicRenderingFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceDynamicRenderingFeaturesKHR;
@@ -50955,27 +47965,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceDynamicRenderingFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDynamicRenderingFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceDynamicRenderingFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceDynamicRenderingFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, dynamicRendering );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDynamicRenderingFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51000,26 +48020,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDynamicRenderingFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR const &
-                            physicalDeviceDynamicRenderingFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDynamicRenderingFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDynamicRenderingFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDynamicRenderingFeaturesKHR.dynamicRendering );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExclusiveScissorFeaturesNV
   {
     using NativeType = VkPhysicalDeviceExclusiveScissorFeaturesNV;
@@ -51068,27 +48068,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, exclusiveScissor );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51113,26 +48123,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExclusiveScissorFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const &
-                            physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExclusiveScissorFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExclusiveScissorFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
@@ -51201,30 +48191,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( extendedDynamicState2 == rhs.extendedDynamicState2 ) &&
-             ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) &&
-             ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51251,31 +48253,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const &
-                            physicalDeviceExtendedDynamicState2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;
@@ -51326,27 +48303,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, extendedDynamicState );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51371,26 +48358,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const &
-                            physicalDeviceExtendedDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExternalBufferInfo
   {
     using NativeType = VkPhysicalDeviceExternalBufferInfo;
@@ -51455,28 +48422,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( this );
     }
 
-    operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::BufferCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::BufferUsageFlags const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, usage, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51504,28 +48484,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalBufferInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalBufferInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, physicalDeviceExternalBufferInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, physicalDeviceExternalBufferInfo.usage );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalBufferInfo.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExternalFenceInfo
   {
     using NativeType = VkPhysicalDeviceExternalFenceInfo;
@@ -51572,27 +48530,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( this );
     }
 
-    operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51618,26 +48588,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalFenceInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalFenceInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, physicalDeviceExternalFenceInfo.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExternalImageFormatInfo
   {
     using NativeType = VkPhysicalDeviceExternalImageFormatInfo;
@@ -51687,27 +48637,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>( this );
     }
 
-    operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51733,25 +48695,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const &
-                            physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalImageFormatInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalImageFormatInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalImageFormatInfo.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExternalMemoryHostPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
@@ -51786,28 +48729,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, minImportedHostPointerAlignment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51832,27 +48784,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const &
-                            physicalDeviceExternalMemoryHostPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
-                             seed,
-                             physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV
   {
     using NativeType = VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;
@@ -51902,27 +48833,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, externalMemoryRDMA );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -51947,26 +48888,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const &
-                            physicalDeviceExternalMemoryRDMAFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceExternalSemaphoreInfo
   {
     using NativeType = VkPhysicalDeviceExternalSemaphoreInfo;
@@ -52015,27 +48936,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( this );
     }
 
-    operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52061,25 +48994,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const &
-                            physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalSemaphoreInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalSemaphoreInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, physicalDeviceExternalSemaphoreInfo.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFeatures2
   {
     using NativeType = VkPhysicalDeviceFeatures2;
@@ -52123,27 +49037,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFeatures2 *>( this );
     }
 
-    operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFeatures2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, features );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52167,24 +49093,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFeatures2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFeatures2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures, seed, physicalDeviceFeatures2.features );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFloatControlsProperties
   {
     using NativeType = VkPhysicalDeviceFloatControlsProperties;
@@ -52252,44 +49160,73 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties *>( this );
     }
 
-    operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFloatControlsProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+               VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       denormBehaviorIndependence,
+                       roundingModeIndependence,
+                       shaderSignedZeroInfNanPreserveFloat16,
+                       shaderSignedZeroInfNanPreserveFloat32,
+                       shaderSignedZeroInfNanPreserveFloat64,
+                       shaderDenormPreserveFloat16,
+                       shaderDenormPreserveFloat32,
+                       shaderDenormPreserveFloat64,
+                       shaderDenormFlushToZeroFloat16,
+                       shaderDenormFlushToZeroFloat32,
+                       shaderDenormFlushToZeroFloat64,
+                       shaderRoundingModeRTEFloat16,
+                       shaderRoundingModeRTEFloat32,
+                       shaderRoundingModeRTEFloat64,
+                       shaderRoundingModeRTZFloat16,
+                       shaderRoundingModeRTZFloat32,
+                       shaderRoundingModeRTZFloat64 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) &&
-             ( roundingModeIndependence == rhs.roundingModeIndependence ) &&
-             ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) &&
-             ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) &&
-             ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) &&
-             ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) &&
-             ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) &&
-             ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) &&
-             ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) &&
-             ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) &&
-             ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) &&
-             ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) &&
-             ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) &&
-             ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) &&
-             ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) &&
-             ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) &&
-             ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52332,59 +49269,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const &
-                            physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFloatControlsProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFloatControlsProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
-                             seed,
-                             physicalDeviceFloatControlsProperties.denormBehaviorIndependence );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
-                             seed,
-                             physicalDeviceFloatControlsProperties.roundingModeIndependence );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;
@@ -52434,28 +49318,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fragmentDensityMapDeferred );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52480,26 +49373,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const &
-                            physicalDeviceFragmentDensityMap2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;
@@ -52540,30 +49413,47 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       subsampledLoads,
+                       subsampledCoarseReconstructionEarlyAccess,
+                       maxSubsampledArrayLayers,
+                       maxDescriptorSetSubsampledSamplers );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) &&
-             ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) &&
-             ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) &&
-             ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52591,32 +49481,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const &
-                            physicalDeviceFragmentDensityMap2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentDensityMapFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
@@ -52684,29 +49548,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) &&
-             ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) &&
-             ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52733,31 +49610,202 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
+  struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
+  {
+    using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
 
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const &
-                            physicalDeviceFragmentDensityMapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages );
-    return seed;
-  }
-};
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+      VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ = {} ) VULKAN_HPP_NOEXCEPT
+      : fragmentDensityMapOffset( fragmentDensityMapOffset_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+      PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+      VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+          *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs ) )
+    {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+      operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+      operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this =
+        *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+                            setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+      setFragmentDensityMapOffset( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityMapOffset = fragmentDensityMapOffset_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    explicit operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
+    }
+
+    explicit operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
+    }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fragmentDensityMapOffset );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() == rhs.reflect();
+    }
+
+    bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() != rhs.reflect();
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+    void *                              pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32        fragmentDensityMapOffset = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) ==
+                              sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ),
+                            "struct and wrapper have different size!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
+    "struct wrapper is not a standard layout!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
+    "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
+  {
+    using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+  };
+
+  struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
+  {
+    using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+      VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity_ = {} ) VULKAN_HPP_NOEXCEPT
+      : fragmentDensityOffsetGranularity( fragmentDensityOffsetGranularity_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+      PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+      VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+          *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs ) )
+    {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &
+      operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &
+      operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this =
+        *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs );
+      return *this;
+    }
+
+    explicit operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
+    }
+
+    explicit operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
+    }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fragmentDensityOffsetGranularity );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() == rhs.reflect();
+    }
+
+    bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() != rhs.reflect();
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+    void *                              pNext = {};
+    VULKAN_HPP_NAMESPACE::Extent2D      fragmentDensityOffsetGranularity = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) ==
+                              sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ),
+                            "struct and wrapper have different size!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
+    "struct wrapper is not a standard layout!" );
+  VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<
+                              VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
+                            "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
+  {
+    using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+  };
 
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentDensityMapPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
@@ -52796,30 +49844,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) &&
-             ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) &&
-             ( fragmentDensityInvocations == rhs.fragmentDensityInvocations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52846,30 +49906,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const &
-                            physicalDeviceFragmentDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
   {
     using NativeType = VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
@@ -52921,28 +49957,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fragmentShaderBarycentric );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -52967,26 +50012,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const &
-                            physicalDeviceFragmentShaderBarycentricFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.fragmentShaderBarycentric );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
@@ -53055,30 +50080,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) &&
-             ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) &&
-             ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -53105,33 +50142,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const &
-                            physicalDeviceFragmentShaderInterlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
@@ -53200,30 +50210,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) &&
-             ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) &&
-             ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -53250,32 +50272,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &
-                            physicalDeviceFragmentShadingRateEnumsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
@@ -53329,28 +50325,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -53376,27 +50383,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &
-                            physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits,
-                             seed,
-                             physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentShadingRateFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
@@ -53464,30 +50450,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) &&
-             ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) &&
-             ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -53514,30 +50512,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const &
-                            physicalDeviceFragmentShadingRateFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentShadingRateKHR
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateKHR;
@@ -53572,28 +50546,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateKHR *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, sampleCounts, fragmentSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) &&
-             ( fragmentSize == rhs.fragmentSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -53618,26 +50604,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const &
-                            physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceFragmentShadingRateKHR.sampleCounts );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRateKHR.fragmentSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceFragmentShadingRatePropertiesKHR
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRatePropertiesKHR;
@@ -53705,48 +50671,73 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       minFragmentShadingRateAttachmentTexelSize,
+                       maxFragmentShadingRateAttachmentTexelSize,
+                       maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
+                       primitiveFragmentShadingRateWithMultipleViewports,
+                       layeredShadingRateAttachments,
+                       fragmentShadingRateNonTrivialCombinerOps,
+                       maxFragmentSize,
+                       maxFragmentSizeAspectRatio,
+                       maxFragmentShadingRateCoverageSamples,
+                       maxFragmentShadingRateRasterizationSamples,
+                       fragmentShadingRateWithShaderDepthStencilWrites,
+                       fragmentShadingRateWithSampleMask,
+                       fragmentShadingRateWithShaderSampleMask,
+                       fragmentShadingRateWithConservativeRasterization,
+                       fragmentShadingRateWithFragmentShaderInterlock,
+                       fragmentShadingRateWithCustomSampleLocations,
+                       fragmentShadingRateStrictMultiplyCombiner );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( minFragmentShadingRateAttachmentTexelSize == rhs.minFragmentShadingRateAttachmentTexelSize ) &&
-             ( maxFragmentShadingRateAttachmentTexelSize == rhs.maxFragmentShadingRateAttachmentTexelSize ) &&
-             ( maxFragmentShadingRateAttachmentTexelSizeAspectRatio ==
-               rhs.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ) &&
-             ( primitiveFragmentShadingRateWithMultipleViewports ==
-               rhs.primitiveFragmentShadingRateWithMultipleViewports ) &&
-             ( layeredShadingRateAttachments == rhs.layeredShadingRateAttachments ) &&
-             ( fragmentShadingRateNonTrivialCombinerOps == rhs.fragmentShadingRateNonTrivialCombinerOps ) &&
-             ( maxFragmentSize == rhs.maxFragmentSize ) &&
-             ( maxFragmentSizeAspectRatio == rhs.maxFragmentSizeAspectRatio ) &&
-             ( maxFragmentShadingRateCoverageSamples == rhs.maxFragmentShadingRateCoverageSamples ) &&
-             ( maxFragmentShadingRateRasterizationSamples == rhs.maxFragmentShadingRateRasterizationSamples ) &&
-             ( fragmentShadingRateWithShaderDepthStencilWrites ==
-               rhs.fragmentShadingRateWithShaderDepthStencilWrites ) &&
-             ( fragmentShadingRateWithSampleMask == rhs.fragmentShadingRateWithSampleMask ) &&
-             ( fragmentShadingRateWithShaderSampleMask == rhs.fragmentShadingRateWithShaderSampleMask ) &&
-             ( fragmentShadingRateWithConservativeRasterization ==
-               rhs.fragmentShadingRateWithConservativeRasterization ) &&
-             ( fragmentShadingRateWithFragmentShaderInterlock == rhs.fragmentShadingRateWithFragmentShaderInterlock ) &&
-             ( fragmentShadingRateWithCustomSampleLocations == rhs.fragmentShadingRateWithCustomSampleLocations ) &&
-             ( fragmentShadingRateStrictMultiplyCombiner == rhs.fragmentShadingRateStrictMultiplyCombiner );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -53788,79 +50779,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const &
-                            physicalDeviceFragmentShadingRatePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
-                             seed,
-                             physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
-                             seed,
-                             physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t,
-      seed,
-      physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits,
-      seed,
-      physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;
@@ -53910,27 +50828,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, globalPriorityQuery );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -53955,26 +50883,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT const &
-                            physicalDeviceGlobalPriorityQueryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.globalPriorityQuery );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceGroupProperties
   {
     using NativeType = VkPhysicalDeviceGroupProperties;
@@ -54009,28 +50917,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceGroupProperties *>( this );
     }
 
-    operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceGroupProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<
+      VULKAN_HPP_NAMESPACE::StructureType const &,
+      void * const &,
+      uint32_t const &,
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::PhysicalDevice, VK_MAX_DEVICE_GROUP_SIZE> const &,
+      VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceGroupProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
-             ( physicalDevices == rhs.physicalDevices ) && ( subsetAllocation == rhs.subsetAllocation );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54058,30 +50980,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGroupProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGroupProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceGroupProperties.physicalDeviceCount );
-    for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE(
-        VULKAN_HPP_NAMESPACE::PhysicalDevice, seed, physicalDeviceGroupProperties.physicalDevices[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGroupProperties.subsetAllocation );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceHostQueryResetFeatures
   {
     using NativeType = VkPhysicalDeviceHostQueryResetFeatures;
@@ -54129,27 +51027,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, hostQueryReset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54174,24 +51082,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const &
-                            physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceHostQueryResetFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceHostQueryResetFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceHostQueryResetFeatures.hostQueryReset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceIDProperties
   {
     using NativeType = VkPhysicalDeviceIDProperties;
@@ -54229,29 +51119,43 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceIDProperties *>( this );
     }
 
-    operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceIDProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceIDProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) &&
-             ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) &&
-             ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54279,37 +51183,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIDProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIDProperties.pNext );
-    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceUUID[i] );
-    }
-    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.driverUUID[i] );
-    }
-    for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceLUID[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceIDProperties.deviceNodeMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIDProperties.deviceLUIDValid );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceImageDrmFormatModifierInfoEXT
   {
     using NativeType = VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
@@ -54409,29 +51282,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>( this );
     }
 
-    operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::SharingMode const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) &&
-             ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
-             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54459,29 +51345,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const &
-                            physicalDeviceImageDrmFormatModifierInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SharingMode, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceImageFormatInfo2
   {
     using NativeType = VkPhysicalDeviceImageFormatInfo2;
@@ -54563,28 +51426,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( this );
     }
 
-    operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::ImageType const &,
+               VULKAN_HPP_NAMESPACE::ImageTiling const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+               VULKAN_HPP_NAMESPACE::ImageCreateFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, format, type, tiling, usage, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) &&
-             ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54613,28 +51491,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageFormatInfo2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageFormatInfo2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceImageFormatInfo2.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceImageFormatInfo2.type );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceImageFormatInfo2.tiling );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceImageFormatInfo2.usage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, physicalDeviceImageFormatInfo2.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceImageRobustnessFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceImageRobustnessFeaturesEXT;
@@ -54684,27 +51540,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceImageRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, robustImageAccess );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageRobustnessFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54729,26 +51595,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageRobustnessFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT const &
-                            physicalDeviceImageRobustnessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageRobustnessFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageRobustnessFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageRobustnessFeaturesEXT.robustImageAccess );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceImageViewImageFormatInfoEXT
   {
     using NativeType = VkPhysicalDeviceImageViewImageFormatInfoEXT;
@@ -54799,27 +51645,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>( this );
     }
 
-    operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageViewType const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imageViewType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54844,26 +51700,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageViewImageFormatInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const &
-                            physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewImageFormatInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewImageFormatInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageViewType, seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceImageViewMinLodFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceImageViewMinLodFeaturesEXT;
@@ -54913,27 +51749,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, minLod );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -54958,25 +51804,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageViewMinLodFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const &
-                            physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewMinLodFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceImagelessFramebufferFeatures
   {
     using NativeType = VkPhysicalDeviceImagelessFramebufferFeatures;
@@ -55026,27 +51853,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imagelessFramebuffer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -55072,26 +51909,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const &
-                            physicalDeviceImagelessFramebufferFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImagelessFramebufferFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImagelessFramebufferFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceIndexTypeUint8FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
@@ -55140,27 +51957,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, indexTypeUint8 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -55185,25 +52012,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const &
-                            physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceInheritedViewportScissorFeaturesNV
   {
     using NativeType = VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
@@ -55254,28 +52062,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, inheritedViewportScissor2D );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -55300,26 +52117,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const &
-                            physicalDeviceInheritedViewportScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceInlineUniformBlockFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
@@ -55379,29 +52176,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) &&
-             ( descriptorBindingInlineUniformBlockUpdateAfterBind ==
-               rhs.descriptorBindingInlineUniformBlockUpdateAfterBind );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -55427,30 +52235,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInlineUniformBlockFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT const &
-                            physicalDeviceInlineUniformBlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInlineUniformBlockFeaturesEXT.inlineUniformBlock );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceInlineUniformBlockFeaturesEXT.descriptorBindingInlineUniformBlockUpdateAfterBind );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceInlineUniformBlockPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
@@ -55494,34 +52278,49 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       maxInlineUniformBlockSize,
+                       maxPerStageDescriptorInlineUniformBlocks,
+                       maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+                       maxDescriptorSetInlineUniformBlocks,
+                       maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) &&
-             ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) &&
-             ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ==
-               rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) &&
-             ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) &&
-             ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks ==
-               rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -55550,37 +52349,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInlineUniformBlockPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT const &
-                            physicalDeviceInlineUniformBlockPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxInlineUniformBlockSize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorInlineUniformBlocks );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t,
-      seed,
-      physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetInlineUniformBlocks );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t,
-      seed,
-      physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI
   {
     using NativeType = VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;
@@ -55629,27 +52397,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>( this );
     }
 
-    operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, invocationMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -55674,26 +52452,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const &
-                            physicalDeviceInvocationMaskFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceLimits
   {
     using NativeType = VkPhysicalDeviceLimits;
@@ -55929,125 +52687,247 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceLimits *>( this );
     }
 
-    operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceLimits *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               float const &,
+               float const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 2> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+               uint32_t const &,
+               size_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               int32_t const &,
+               uint32_t const &,
+               int32_t const &,
+               uint32_t const &,
+               float const &,
+               float const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               float const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+               float const &,
+               float const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( maxImageDimension1D,
+                       maxImageDimension2D,
+                       maxImageDimension3D,
+                       maxImageDimensionCube,
+                       maxImageArrayLayers,
+                       maxTexelBufferElements,
+                       maxUniformBufferRange,
+                       maxStorageBufferRange,
+                       maxPushConstantsSize,
+                       maxMemoryAllocationCount,
+                       maxSamplerAllocationCount,
+                       bufferImageGranularity,
+                       sparseAddressSpaceSize,
+                       maxBoundDescriptorSets,
+                       maxPerStageDescriptorSamplers,
+                       maxPerStageDescriptorUniformBuffers,
+                       maxPerStageDescriptorStorageBuffers,
+                       maxPerStageDescriptorSampledImages,
+                       maxPerStageDescriptorStorageImages,
+                       maxPerStageDescriptorInputAttachments,
+                       maxPerStageResources,
+                       maxDescriptorSetSamplers,
+                       maxDescriptorSetUniformBuffers,
+                       maxDescriptorSetUniformBuffersDynamic,
+                       maxDescriptorSetStorageBuffers,
+                       maxDescriptorSetStorageBuffersDynamic,
+                       maxDescriptorSetSampledImages,
+                       maxDescriptorSetStorageImages,
+                       maxDescriptorSetInputAttachments,
+                       maxVertexInputAttributes,
+                       maxVertexInputBindings,
+                       maxVertexInputAttributeOffset,
+                       maxVertexInputBindingStride,
+                       maxVertexOutputComponents,
+                       maxTessellationGenerationLevel,
+                       maxTessellationPatchSize,
+                       maxTessellationControlPerVertexInputComponents,
+                       maxTessellationControlPerVertexOutputComponents,
+                       maxTessellationControlPerPatchOutputComponents,
+                       maxTessellationControlTotalOutputComponents,
+                       maxTessellationEvaluationInputComponents,
+                       maxTessellationEvaluationOutputComponents,
+                       maxGeometryShaderInvocations,
+                       maxGeometryInputComponents,
+                       maxGeometryOutputComponents,
+                       maxGeometryOutputVertices,
+                       maxGeometryTotalOutputComponents,
+                       maxFragmentInputComponents,
+                       maxFragmentOutputAttachments,
+                       maxFragmentDualSrcAttachments,
+                       maxFragmentCombinedOutputResources,
+                       maxComputeSharedMemorySize,
+                       maxComputeWorkGroupCount,
+                       maxComputeWorkGroupInvocations,
+                       maxComputeWorkGroupSize,
+                       subPixelPrecisionBits,
+                       subTexelPrecisionBits,
+                       mipmapPrecisionBits,
+                       maxDrawIndexedIndexValue,
+                       maxDrawIndirectCount,
+                       maxSamplerLodBias,
+                       maxSamplerAnisotropy,
+                       maxViewports,
+                       maxViewportDimensions,
+                       viewportBoundsRange,
+                       viewportSubPixelBits,
+                       minMemoryMapAlignment,
+                       minTexelBufferOffsetAlignment,
+                       minUniformBufferOffsetAlignment,
+                       minStorageBufferOffsetAlignment,
+                       minTexelOffset,
+                       maxTexelOffset,
+                       minTexelGatherOffset,
+                       maxTexelGatherOffset,
+                       minInterpolationOffset,
+                       maxInterpolationOffset,
+                       subPixelInterpolationOffsetBits,
+                       maxFramebufferWidth,
+                       maxFramebufferHeight,
+                       maxFramebufferLayers,
+                       framebufferColorSampleCounts,
+                       framebufferDepthSampleCounts,
+                       framebufferStencilSampleCounts,
+                       framebufferNoAttachmentsSampleCounts,
+                       maxColorAttachments,
+                       sampledImageColorSampleCounts,
+                       sampledImageIntegerSampleCounts,
+                       sampledImageDepthSampleCounts,
+                       sampledImageStencilSampleCounts,
+                       storageImageSampleCounts,
+                       maxSampleMaskWords,
+                       timestampComputeAndGraphics,
+                       timestampPeriod,
+                       maxClipDistances,
+                       maxCullDistances,
+                       maxCombinedClipAndCullDistances,
+                       discreteQueuePriorities,
+                       pointSizeRange,
+                       lineWidthRange,
+                       pointSizeGranularity,
+                       lineWidthGranularity,
+                       strictLines,
+                       standardSampleLocations,
+                       optimalBufferCopyOffsetAlignment,
+                       optimalBufferCopyRowPitchAlignment,
+                       nonCoherentAtomSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceLimits const & ) const = default;
 #else
     bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( maxImageDimension1D == rhs.maxImageDimension1D ) && ( maxImageDimension2D == rhs.maxImageDimension2D ) &&
-             ( maxImageDimension3D == rhs.maxImageDimension3D ) &&
-             ( maxImageDimensionCube == rhs.maxImageDimensionCube ) &&
-             ( maxImageArrayLayers == rhs.maxImageArrayLayers ) &&
-             ( maxTexelBufferElements == rhs.maxTexelBufferElements ) &&
-             ( maxUniformBufferRange == rhs.maxUniformBufferRange ) &&
-             ( maxStorageBufferRange == rhs.maxStorageBufferRange ) &&
-             ( maxPushConstantsSize == rhs.maxPushConstantsSize ) &&
-             ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) &&
-             ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) &&
-             ( bufferImageGranularity == rhs.bufferImageGranularity ) &&
-             ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) &&
-             ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) &&
-             ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) &&
-             ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) &&
-             ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) &&
-             ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) &&
-             ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) &&
-             ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) &&
-             ( maxPerStageResources == rhs.maxPerStageResources ) &&
-             ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) &&
-             ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) &&
-             ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) &&
-             ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) &&
-             ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) &&
-             ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) &&
-             ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) &&
-             ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) &&
-             ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) &&
-             ( maxVertexInputBindings == rhs.maxVertexInputBindings ) &&
-             ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) &&
-             ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) &&
-             ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) &&
-             ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) &&
-             ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) &&
-             ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) &&
-             ( maxTessellationControlPerVertexOutputComponents ==
-               rhs.maxTessellationControlPerVertexOutputComponents ) &&
-             ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) &&
-             ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) &&
-             ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) &&
-             ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) &&
-             ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) &&
-             ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) &&
-             ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) &&
-             ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) &&
-             ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) &&
-             ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) &&
-             ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) &&
-             ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) &&
-             ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) &&
-             ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) &&
-             ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount ) &&
-             ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) &&
-             ( maxComputeWorkGroupSize == rhs.maxComputeWorkGroupSize ) &&
-             ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) &&
-             ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) &&
-             ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) &&
-             ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) &&
-             ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) &&
-             ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) && ( maxViewports == rhs.maxViewports ) &&
-             ( maxViewportDimensions == rhs.maxViewportDimensions ) &&
-             ( viewportBoundsRange == rhs.viewportBoundsRange ) &&
-             ( viewportSubPixelBits == rhs.viewportSubPixelBits ) &&
-             ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) &&
-             ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) &&
-             ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) &&
-             ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) &&
-             ( minTexelOffset == rhs.minTexelOffset ) && ( maxTexelOffset == rhs.maxTexelOffset ) &&
-             ( minTexelGatherOffset == rhs.minTexelGatherOffset ) &&
-             ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) &&
-             ( minInterpolationOffset == rhs.minInterpolationOffset ) &&
-             ( maxInterpolationOffset == rhs.maxInterpolationOffset ) &&
-             ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) &&
-             ( maxFramebufferWidth == rhs.maxFramebufferWidth ) &&
-             ( maxFramebufferHeight == rhs.maxFramebufferHeight ) &&
-             ( maxFramebufferLayers == rhs.maxFramebufferLayers ) &&
-             ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) &&
-             ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) &&
-             ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) &&
-             ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) &&
-             ( maxColorAttachments == rhs.maxColorAttachments ) &&
-             ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) &&
-             ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) &&
-             ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) &&
-             ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) &&
-             ( storageImageSampleCounts == rhs.storageImageSampleCounts ) &&
-             ( maxSampleMaskWords == rhs.maxSampleMaskWords ) &&
-             ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) &&
-             ( timestampPeriod == rhs.timestampPeriod ) && ( maxClipDistances == rhs.maxClipDistances ) &&
-             ( maxCullDistances == rhs.maxCullDistances ) &&
-             ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) &&
-             ( discreteQueuePriorities == rhs.discreteQueuePriorities ) && ( pointSizeRange == rhs.pointSizeRange ) &&
-             ( lineWidthRange == rhs.lineWidthRange ) && ( pointSizeGranularity == rhs.pointSizeGranularity ) &&
-             ( lineWidthGranularity == rhs.lineWidthGranularity ) && ( strictLines == rhs.strictLines ) &&
-             ( standardSampleLocations == rhs.standardSampleLocations ) &&
-             ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) &&
-             ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) &&
-             ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -56166,159 +53046,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>::value,
                             "PhysicalDeviceLimits is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension1D );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension2D );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension3D );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimensionCube );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageArrayLayers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelBufferElements );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxUniformBufferRange );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxStorageBufferRange );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPushConstantsSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxMemoryAllocationCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSamplerAllocationCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.bufferImageGranularity );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.sparseAddressSpaceSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxBoundDescriptorSets );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSamplers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageResources );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSamplers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSampledImages );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageImages );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetInputAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributes );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindings );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributeOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindingStride );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexOutputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationGenerationLevel );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationPatchSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryShaderInvocations );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryInputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputVertices );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryTotalOutputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentInputComponents );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentOutputAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentDualSrcAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentCombinedOutputResources );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeSharedMemorySize );
-    for ( size_t i = 0; i < 3; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupInvocations );
-    for ( size_t i = 0; i < 3; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelPrecisionBits );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subTexelPrecisionBits );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.mipmapPrecisionBits );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndexedIndexValue );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndirectCount );
-    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerLodBias );
-    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerAnisotropy );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewports );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewportDimensions[i] );
-    }
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.viewportBoundsRange[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.viewportSubPixelBits );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, physicalDeviceLimits.minMemoryMapAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minTexelBufferOffsetAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minUniformBufferOffsetAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minStorageBufferOffsetAlignment );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelOffset );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelGatherOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelGatherOffset );
-    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.minInterpolationOffset );
-    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxInterpolationOffset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelInterpolationOffsetBits );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferWidth );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferHeight );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferLayers );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferColorSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferDepthSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferStencilSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxColorAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageColorSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageIntegerSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageDepthSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageStencilSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.storageImageSampleCounts );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSampleMaskWords );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.timestampComputeAndGraphics );
-    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.timestampPeriod );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxClipDistances );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCullDistances );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCombinedClipAndCullDistances );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.discreteQueuePriorities );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeRange[i] );
-    }
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthRange[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeGranularity );
-    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthGranularity );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.strictLines );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.standardSampleLocations );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.nonCoherentAtomSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceLineRasterizationFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceLineRasterizationFeaturesEXT;
@@ -56413,31 +53140,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       rectangularLines,
+                       bresenhamLines,
+                       smoothLines,
+                       stippledRectangularLines,
+                       stippledBresenhamLines,
+                       stippledSmoothLines );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) &&
-             ( bresenhamLines == rhs.bresenhamLines ) && ( smoothLines == rhs.smoothLines ) &&
-             ( stippledRectangularLines == rhs.stippledRectangularLines ) &&
-             ( stippledBresenhamLines == rhs.stippledBresenhamLines ) &&
-             ( stippledSmoothLines == rhs.stippledSmoothLines );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -56467,36 +53214,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceLineRasterizationFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const &
-                            physicalDeviceLineRasterizationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceLineRasterizationPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceLineRasterizationPropertiesEXT;
@@ -56531,28 +53248,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceLineRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceLineRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, lineSubPixelPrecisionBits );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -56577,25 +53303,111 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceLineRasterizationPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
+  struct PhysicalDeviceLinearColorAttachmentFeaturesNV
+  {
+    using NativeType = VkPhysicalDeviceLinearColorAttachmentFeaturesNV;
 
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const &
-                            physicalDeviceLineRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits );
-    return seed;
-  }
-};
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV(
+      VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment_ = {} ) VULKAN_HPP_NOEXCEPT
+      : linearColorAttachment( linearColorAttachment_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV(
+      PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceLinearColorAttachmentFeaturesNV( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs )
+      VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceLinearColorAttachmentFeaturesNV(
+          *reinterpret_cast<PhysicalDeviceLinearColorAttachmentFeaturesNV const *>( &rhs ) )
+    {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceLinearColorAttachmentFeaturesNV &
+      operator=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceLinearColorAttachmentFeaturesNV &
+      operator=( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV &
+                            setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV &
+      setLinearColorAttachment( VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment_ ) VULKAN_HPP_NOEXCEPT
+    {
+      linearColorAttachment = linearColorAttachment_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    explicit operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>( this );
+    }
+
+    explicit operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>( this );
+    }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, linearColorAttachment );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceLinearColorAttachmentFeaturesNV const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() == rhs.reflect();
+    }
+
+    bool operator!=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() != rhs.reflect();
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV;
+    void *                              pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32        linearColorAttachment = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV ) ==
+                              sizeof( VkPhysicalDeviceLinearColorAttachmentFeaturesNV ),
+                            "struct and wrapper have different size!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>::value,
+    "struct wrapper is not a standard layout!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>::value,
+    "PhysicalDeviceLinearColorAttachmentFeaturesNV is not nothrow_move_constructible!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV>
+  {
+    using Type = PhysicalDeviceLinearColorAttachmentFeaturesNV;
+  };
 
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMaintenance3Properties
   {
     using NativeType = VkPhysicalDeviceMaintenance3Properties;
@@ -56630,28 +53442,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>( this );
     }
 
-    operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) &&
-             ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -56677,26 +53501,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const &
-                            physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance3Properties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance3Properties.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMaintenance4FeaturesKHR
   {
     using NativeType = VkPhysicalDeviceMaintenance4FeaturesKHR;
@@ -56745,27 +53549,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceMaintenance4FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMaintenance4FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceMaintenance4FeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMaintenance4FeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maintenance4 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMaintenance4FeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -56789,24 +53603,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMaintenance4FeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR const &
-                            physicalDeviceMaintenance4FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4FeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4FeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMaintenance4FeaturesKHR.maintenance4 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMaintenance4PropertiesKHR
   {
     using NativeType = VkPhysicalDeviceMaintenance4PropertiesKHR;
@@ -56839,27 +53635,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMaintenance4PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMaintenance4PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceMaintenance4PropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMaintenance4PropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxBufferSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMaintenance4PropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -56884,25 +53690,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMaintenance4PropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR const &
-                            physicalDeviceMaintenance4PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4PropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4PropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance4PropertiesKHR.maxBufferSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMemoryBudgetPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceMemoryBudgetPropertiesEXT;
@@ -56938,28 +53725,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, heapBudget, heapUsage );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) &&
-             ( heapUsage == rhs.heapUsage );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -56985,33 +53784,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMemoryBudgetPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const &
-                            physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryBudgetPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext );
-    for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE(
-        VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE(
-        VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMemoryPriorityFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceMemoryPriorityFeaturesEXT;
@@ -57060,27 +53832,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryPriority );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57105,25 +53887,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMemoryPriorityFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const &
-                            physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryPriorityFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMemoryProperties
   {
     using NativeType = VkPhysicalDeviceMemoryProperties;
@@ -57157,28 +53920,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties *>( this );
     }
 
-    operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryType, VK_MAX_MEMORY_TYPES> const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryHeap, VK_MAX_MEMORY_HEAPS> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memoryTypes == rhs.memoryTypes ) &&
-             ( memoryHeapCount == rhs.memoryHeapCount ) && ( memoryHeaps == rhs.memoryHeaps );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57197,31 +53972,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>::value,
     "PhysicalDeviceMemoryProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryTypeCount );
-    for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryType, seed, physicalDeviceMemoryProperties.memoryTypes[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryHeapCount );
-    for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeap, seed, physicalDeviceMemoryProperties.memoryHeaps[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMemoryProperties2
   {
     using NativeType = VkPhysicalDeviceMemoryProperties2;
@@ -57252,27 +54002,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2 *>( this );
     }
 
-    operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57297,26 +54059,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryProperties2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryProperties2.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties, seed, physicalDeviceMemoryProperties2.memoryProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMeshShaderFeaturesNV
   {
     using NativeType = VkPhysicalDeviceMeshShaderFeaturesNV;
@@ -57373,28 +54115,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, taskShader, meshShader );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) &&
-             ( meshShader == rhs.meshShader );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57419,25 +54173,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMeshShaderFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const &
-                            physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.taskShader );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.meshShader );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMeshShaderPropertiesNV
   {
     using NativeType = VkPhysicalDeviceMeshShaderPropertiesNV;
@@ -57494,40 +54229,65 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>( this );
     }
 
-    operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       maxDrawMeshTasksCount,
+                       maxTaskWorkGroupInvocations,
+                       maxTaskWorkGroupSize,
+                       maxTaskTotalMemorySize,
+                       maxTaskOutputCount,
+                       maxMeshWorkGroupInvocations,
+                       maxMeshWorkGroupSize,
+                       maxMeshTotalMemorySize,
+                       maxMeshOutputVertices,
+                       maxMeshOutputPrimitives,
+                       maxMeshMultiviewViewCount,
+                       meshOutputPerVertexGranularity,
+                       meshOutputPerPrimitiveGranularity );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) &&
-             ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) &&
-             ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) &&
-             ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) &&
-             ( maxTaskOutputCount == rhs.maxTaskOutputCount ) &&
-             ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) &&
-             ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) &&
-             ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) &&
-             ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) &&
-             ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) &&
-             ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) &&
-             ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) &&
-             ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57563,42 +54323,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMeshShaderPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const &
-                            physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations );
-    for ( size_t i = 0; i < 3; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations );
-    for ( size_t i = 0; i < 3; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMultiDrawFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceMultiDrawFeaturesEXT;
@@ -57646,27 +54370,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, multiDraw );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57690,24 +54424,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMultiDrawFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const &
-                            physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMultiDrawPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceMultiDrawPropertiesEXT;
@@ -57739,27 +54455,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxMultiDrawCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57783,24 +54509,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMultiDrawPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const &
-                            physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMultiviewFeatures
   {
     using NativeType = VkPhysicalDeviceMultiviewFeatures;
@@ -57864,29 +54572,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) &&
-             ( multiviewGeometryShader == rhs.multiviewGeometryShader ) &&
-             ( multiviewTessellationShader == rhs.multiviewTessellationShader );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -57913,29 +54633,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiview );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
   {
     using NativeType = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
@@ -57971,28 +54668,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>( this );
     }
 
-    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, perViewPositionAllComponents );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58018,27 +54724,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &
-                            physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMultiviewProperties
   {
     using NativeType = VkPhysicalDeviceMultiviewProperties;
@@ -58072,29 +54757,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>( this );
     }
 
-    operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) &&
-             ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58120,25 +54813,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const &
-                            physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
   {
     using NativeType = VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
@@ -58189,27 +54863,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
     }
 
-    operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, mutableDescriptorType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58234,26 +54918,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &
-                            physicalDeviceMutableDescriptorTypeFeaturesVALVE ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.mutableDescriptorType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePCIBusInfoPropertiesEXT
   {
     using NativeType = VkPhysicalDevicePCIBusInfoPropertiesEXT;
@@ -58292,28 +54956,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) &&
-             ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && ( pciFunction == rhs.pciFunction );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58340,27 +55018,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePCIBusInfoPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const &
-                            physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePCIBusInfoPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePCIBusInfoPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
@@ -58412,28 +55069,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pageableDeviceLocalMemory );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58458,27 +55124,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &
-                            physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePerformanceQueryFeaturesKHR
   {
     using NativeType = VkPhysicalDevicePerformanceQueryFeaturesKHR;
@@ -58537,29 +55182,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) &&
-             ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58585,29 +55241,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePerformanceQueryFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const &
-                            physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePerformanceQueryPropertiesKHR
   {
     using NativeType = VkPhysicalDevicePerformanceQueryPropertiesKHR;
@@ -58642,28 +55275,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, allowCommandBufferQueryCopies );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58688,26 +55330,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePerformanceQueryPropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const &
-                            physicalDevicePerformanceQueryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryPropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryPropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;
@@ -58759,28 +55381,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pipelineCreationCacheControl );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58806,27 +55437,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT const &
-                            physicalDevicePipelineCreationCacheControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePipelineCreationCacheControlFeaturesEXT.pipelineCreationCacheControl );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
   {
     using NativeType = VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
@@ -58878,28 +55488,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pipelineExecutableInfo );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( pipelineExecutableInfo == rhs.pipelineExecutableInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -58925,27 +55544,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &
-                            physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePointClippingProperties
   {
     using NativeType = VkPhysicalDevicePointClippingProperties;
@@ -58980,27 +55578,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>( this );
     }
 
-    operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePointClippingProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PointClippingBehavior const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pointClippingBehavior );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default;
 #else
     bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -59026,25 +55636,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const &
-                            physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePointClippingProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePointClippingProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDevicePointClippingProperties.pointClippingBehavior );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   struct PhysicalDevicePortabilitySubsetFeaturesKHR
   {
@@ -59221,39 +55812,69 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       constantAlphaColorBlendFactors,
+                       events,
+                       imageViewFormatReinterpretation,
+                       imageViewFormatSwizzle,
+                       imageView2DOn3DImage,
+                       multisampleArrayImage,
+                       mutableComparisonSamplers,
+                       pointPolygons,
+                       samplerMipLodBias,
+                       separateStencilMaskRef,
+                       shaderSampleRateInterpolationFunctions,
+                       tessellationIsolines,
+                       tessellationPointMode,
+                       triangleFans,
+                       vertexAttributeAccessBeyondStride );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default;
 #  else
     bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) && ( events == rhs.events ) &&
-             ( imageViewFormatReinterpretation == rhs.imageViewFormatReinterpretation ) &&
-             ( imageViewFormatSwizzle == rhs.imageViewFormatSwizzle ) &&
-             ( imageView2DOn3DImage == rhs.imageView2DOn3DImage ) &&
-             ( multisampleArrayImage == rhs.multisampleArrayImage ) &&
-             ( mutableComparisonSamplers == rhs.mutableComparisonSamplers ) && ( pointPolygons == rhs.pointPolygons ) &&
-             ( samplerMipLodBias == rhs.samplerMipLodBias ) &&
-             ( separateStencilMaskRef == rhs.separateStencilMaskRef ) &&
-             ( shaderSampleRateInterpolationFunctions == rhs.shaderSampleRateInterpolationFunctions ) &&
-             ( tessellationIsolines == rhs.tessellationIsolines ) &&
-             ( tessellationPointMode == rhs.tessellationPointMode ) && ( triangleFans == rhs.triangleFans ) &&
-             ( vertexAttributeAccessBeyondStride == rhs.vertexAttributeAccessBeyondStride );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -59291,56 +55912,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PhysicalDevicePortabilitySubsetFeaturesKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const &
-                            physicalDevicePortabilitySubsetFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.events );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -59393,28 +55964,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, minVertexInputBindingStrideAlignment );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default;
 #  else
     bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -59438,27 +56018,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PhysicalDevicePortabilitySubsetPropertiesKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const &
-                            physicalDevicePortabilitySubsetPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetPropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct PhysicalDevicePresentIdFeaturesKHR
@@ -59508,27 +56067,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, presentId );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -59552,24 +56121,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePresentIdFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const &
-                            physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentIdFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentIdFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentIdFeaturesKHR.presentId );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePresentWaitFeaturesKHR
   {
     using NativeType = VkPhysicalDevicePresentWaitFeaturesKHR;
@@ -59617,27 +56168,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, presentWait );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -59661,24 +56222,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePresentWaitFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const &
-                            physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentWaitFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentWaitFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentWaitFeaturesKHR.presentWait );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
@@ -59740,29 +56283,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) &&
-             ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -59789,30 +56343,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &
-                            physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePrivateDataFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePrivateDataFeaturesEXT;
@@ -59860,27 +56390,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDevicePrivateDataFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePrivateDataFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDevicePrivateDataFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePrivateDataFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, privateData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePrivateDataFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -59904,24 +56444,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePrivateDataFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT const &
-                            physicalDevicePrivateDataFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrivateDataFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrivateDataFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePrivateDataFeaturesEXT.privateData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSparseProperties
   {
     using NativeType = VkPhysicalDeviceSparseProperties;
@@ -59957,31 +56479,45 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSparseProperties *>( this );
     }
 
-    operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSparseProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( residencyStandard2DBlockShape,
+                       residencyStandard2DMultisampleBlockShape,
+                       residencyStandard3DBlockShape,
+                       residencyAlignedMipSize,
+                       residencyNonResidentStrict );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) &&
-             ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) &&
-             ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) &&
-             ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) &&
-             ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60001,31 +56537,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>::value,
     "PhysicalDeviceSparseProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceProperties
   {
     using NativeType = VkPhysicalDeviceProperties;
@@ -60068,30 +56579,53 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties *>( this );
     }
 
-    operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::PhysicalDeviceType const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const &,
+               VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( apiVersion,
+                       driverVersion,
+                       vendorID,
+                       deviceID,
+                       deviceType,
+                       deviceName,
+                       pipelineCacheUUID,
+                       limits,
+                       sparseProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) &&
-             ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && ( deviceType == rhs.deviceType ) &&
-             ( deviceName == rhs.deviceName ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) &&
-             ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60114,37 +56648,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>::value,
                             "PhysicalDeviceProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.apiVersion );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.driverVersion );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.vendorID );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.deviceID );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceType, seed, physicalDeviceProperties.deviceType );
-    for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceProperties.deviceName[i] );
-    }
-    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceProperties.pipelineCacheUUID[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits, seed, physicalDeviceProperties.limits );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties, seed, physicalDeviceProperties.sparseProperties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceProperties2
   {
     using NativeType = VkPhysicalDeviceProperties2;
@@ -60174,27 +56677,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties2 *>( this );
     }
 
-    operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceProperties2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, properties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProperties2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60218,25 +56733,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProperties2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProperties2.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties, seed, physicalDeviceProperties2.properties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceProtectedMemoryFeatures
   {
     using NativeType = VkPhysicalDeviceProtectedMemoryFeatures;
@@ -60285,27 +56781,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, protectedMemory );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60329,25 +56835,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProtectedMemoryFeatures;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const &
-                            physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryFeatures.protectedMemory );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceProtectedMemoryProperties
   {
     using NativeType = VkPhysicalDeviceProtectedMemoryProperties;
@@ -60381,27 +56868,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>( this );
     }
 
-    operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, protectedNoFault );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60426,25 +56923,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProtectedMemoryProperties;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const &
-                            physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryProperties.protectedNoFault );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceProvokingVertexFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceProvokingVertexFeaturesEXT;
@@ -60503,28 +56981,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) &&
-             ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60550,29 +57040,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProvokingVertexFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const &
-                            physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceProvokingVertexPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceProvokingVertexPropertiesEXT;
@@ -60609,30 +57076,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) &&
-             ( transformFeedbackPreservesTriangleFanProvokingVertex ==
-               rhs.transformFeedbackPreservesTriangleFanProvokingVertex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60658,30 +57136,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProvokingVertexPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const &
-                            physicalDeviceProvokingVertexPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDevicePushDescriptorPropertiesKHR
   {
     using NativeType = VkPhysicalDevicePushDescriptorPropertiesKHR;
@@ -60716,27 +57170,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDevicePushDescriptorPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePushDescriptorPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDevicePushDescriptorPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDevicePushDescriptorPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxPushDescriptors );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60761,25 +57225,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePushDescriptorPropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const &
-                            physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePushDescriptorPropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePushDescriptorPropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT;
@@ -60829,28 +57274,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -60875,26 +57329,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const &
-                            physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
   {
     using NativeType = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
@@ -60968,30 +57402,45 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM *>( this );
     }
 
-    operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       rasterizationOrderColorAttachmentAccess,
+                       rasterizationOrderDepthAttachmentAccess,
+                       rasterizationOrderStencilAttachmentAccess );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) &&
-             ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) &&
-             ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61021,36 +57470,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &
-                            physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderColorAttachmentAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderDepthAttachmentAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderStencilAttachmentAccess );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRayQueryFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR;
@@ -61097,27 +57516,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, rayQuery );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61141,24 +57570,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayQueryFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const &
-                            physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayQueryFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayQueryFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayQueryFeaturesKHR.rayQuery );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV
   {
     using NativeType = VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
@@ -61218,28 +57629,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) &&
-             ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61265,30 +57688,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const &
-                            physicalDeviceRayTracingMotionBlurFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRayTracingPipelineFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
@@ -61376,33 +57775,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       rayTracingPipeline,
+                       rayTracingPipelineShaderGroupHandleCaptureReplay,
+                       rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
+                       rayTracingPipelineTraceRaysIndirect,
+                       rayTraversalPrimitiveCulling );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) &&
-             ( rayTracingPipelineShaderGroupHandleCaptureReplay ==
-               rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) &&
-             ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed ==
-               rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) &&
-             ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) &&
-             ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61431,39 +57846,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const &
-                            physicalDeviceRayTracingPipelineFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRayTracingPipelinePropertiesKHR
   {
     using NativeType = VkPhysicalDeviceRayTracingPipelinePropertiesKHR;
@@ -61512,35 +57894,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       shaderGroupHandleSize,
+                       maxRayRecursionDepth,
+                       maxShaderGroupStride,
+                       shaderGroupBaseAlignment,
+                       shaderGroupHandleCaptureReplaySize,
+                       maxRayDispatchInvocationCount,
+                       shaderGroupHandleAlignment,
+                       maxRayHitAttributeSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) &&
-             ( maxRayRecursionDepth == rhs.maxRayRecursionDepth ) &&
-             ( maxShaderGroupStride == rhs.maxShaderGroupStride ) &&
-             ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) &&
-             ( shaderGroupHandleCaptureReplaySize == rhs.shaderGroupHandleCaptureReplaySize ) &&
-             ( maxRayDispatchInvocationCount == rhs.maxRayDispatchInvocationCount ) &&
-             ( shaderGroupHandleAlignment == rhs.shaderGroupHandleAlignment ) &&
-             ( maxRayHitAttributeSize == rhs.maxRayHitAttributeSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61572,34 +57974,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const &
-                            physicalDeviceRayTracingPipelinePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRayTracingPropertiesNV
   {
     using NativeType = VkPhysicalDeviceRayTracingPropertiesNV;
@@ -61646,33 +58020,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>( this );
     }
 
-    operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint64_t const &,
+               uint64_t const &,
+               uint64_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       shaderGroupHandleSize,
+                       maxRecursionDepth,
+                       maxShaderGroupStride,
+                       shaderGroupBaseAlignment,
+                       maxGeometryCount,
+                       maxInstanceCount,
+                       maxTriangleCount,
+                       maxDescriptorSetAccelerationStructures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) &&
-             ( maxShaderGroupStride == rhs.maxShaderGroupStride ) &&
-             ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) &&
-             ( maxGeometryCount == rhs.maxGeometryCount ) && ( maxInstanceCount == rhs.maxInstanceCount ) &&
-             ( maxTriangleCount == rhs.maxTriangleCount ) &&
-             ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61703,32 +58099,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const &
-                            physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
   {
     using NativeType = VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
@@ -61780,28 +58150,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, representativeFragmentTest );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( representativeFragmentTest == rhs.representativeFragmentTest );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61826,27 +58205,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const &
-                            physicalDeviceRepresentativeFragmentTestFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRobustness2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceRobustness2FeaturesEXT;
@@ -61912,28 +58270,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) &&
-             ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -61959,28 +58330,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRobustness2FeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const &
-                            physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2FeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2FeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceRobustness2PropertiesEXT
   {
     using NativeType = VkPhysicalDeviceRobustness2PropertiesEXT;
@@ -62016,29 +58365,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) &&
-             ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -62064,29 +58424,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRobustness2PropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const &
-                            physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2PropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2PropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
-                             seed,
-                             physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
-                             seed,
-                             physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceSampleLocationsPropertiesEXT;
@@ -62129,32 +58466,49 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       sampleLocationSampleCounts,
+                       maxSampleLocationGridSize,
+                       sampleLocationCoordinateRange,
+                       sampleLocationSubPixelBits,
+                       variableSampleLocations );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) &&
-             ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) &&
-             ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) &&
-             ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) &&
-             ( variableSampleLocations == rhs.variableSampleLocations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -62183,37 +58537,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSampleLocationsPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const &
-                            physicalDeviceSampleLocationsPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSampleLocationsPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSampleLocationsPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags,
-                             seed,
-                             physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE(
-        float, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSamplerFilterMinmaxProperties
   {
     using NativeType = VkPhysicalDeviceSamplerFilterMinmaxProperties;
@@ -62250,29 +58573,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties *>( this );
     }
 
-    operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) &&
-             ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -62299,30 +58633,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const &
-                            physicalDeviceSamplerFilterMinmaxProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerFilterMinmaxProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerFilterMinmaxProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSamplerYcbcrConversionFeatures
   {
     using NativeType = VkPhysicalDeviceSamplerYcbcrConversionFeatures;
@@ -62372,28 +58682,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, samplerYcbcrConversion );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( samplerYcbcrConversion == rhs.samplerYcbcrConversion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -62419,26 +58738,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const &
-                            physicalDeviceSamplerYcbcrConversionFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerYcbcrConversionFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceScalarBlockLayoutFeatures
   {
     using NativeType = VkPhysicalDeviceScalarBlockLayoutFeatures;
@@ -62486,27 +58785,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, scalarBlockLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -62532,25 +58841,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const &
-                            physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceScalarBlockLayoutFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceScalarBlockLayoutFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures
   {
     using NativeType = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
@@ -62602,28 +58892,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, separateDepthStencilLayouts );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -62649,27 +58948,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const &
-                            physicalDeviceSeparateDepthStencilLayoutsFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -62818,39 +59096,63 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       shaderBufferFloat16Atomics,
+                       shaderBufferFloat16AtomicAdd,
+                       shaderBufferFloat16AtomicMinMax,
+                       shaderBufferFloat32AtomicMinMax,
+                       shaderBufferFloat64AtomicMinMax,
+                       shaderSharedFloat16Atomics,
+                       shaderSharedFloat16AtomicAdd,
+                       shaderSharedFloat16AtomicMinMax,
+                       shaderSharedFloat32AtomicMinMax,
+                       shaderSharedFloat64AtomicMinMax,
+                       shaderImageFloat32AtomicMinMax,
+                       sparseImageFloat32AtomicMinMax );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) &&
-             ( shaderBufferFloat16AtomicAdd == rhs.shaderBufferFloat16AtomicAdd ) &&
-             ( shaderBufferFloat16AtomicMinMax == rhs.shaderBufferFloat16AtomicMinMax ) &&
-             ( shaderBufferFloat32AtomicMinMax == rhs.shaderBufferFloat32AtomicMinMax ) &&
-             ( shaderBufferFloat64AtomicMinMax == rhs.shaderBufferFloat64AtomicMinMax ) &&
-             ( shaderSharedFloat16Atomics == rhs.shaderSharedFloat16Atomics ) &&
-             ( shaderSharedFloat16AtomicAdd == rhs.shaderSharedFloat16AtomicAdd ) &&
-             ( shaderSharedFloat16AtomicMinMax == rhs.shaderSharedFloat16AtomicMinMax ) &&
-             ( shaderSharedFloat32AtomicMinMax == rhs.shaderSharedFloat32AtomicMinMax ) &&
-             ( shaderSharedFloat64AtomicMinMax == rhs.shaderSharedFloat64AtomicMinMax ) &&
-             ( shaderImageFloat32AtomicMinMax == rhs.shaderImageFloat32AtomicMinMax ) &&
-             ( sparseImageFloat32AtomicMinMax == rhs.sparseImageFloat32AtomicMinMax );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -62886,48 +59188,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const &
-                            physicalDeviceShaderAtomicFloat2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -63076,39 +59336,63 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       shaderBufferFloat32Atomics,
+                       shaderBufferFloat32AtomicAdd,
+                       shaderBufferFloat64Atomics,
+                       shaderBufferFloat64AtomicAdd,
+                       shaderSharedFloat32Atomics,
+                       shaderSharedFloat32AtomicAdd,
+                       shaderSharedFloat64Atomics,
+                       shaderSharedFloat64AtomicAdd,
+                       shaderImageFloat32Atomics,
+                       shaderImageFloat32AtomicAdd,
+                       sparseImageFloat32Atomics,
+                       sparseImageFloat32AtomicAdd );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) &&
-             ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) &&
-             ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) &&
-             ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) &&
-             ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) &&
-             ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) &&
-             ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) &&
-             ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) &&
-             ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) &&
-             ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) &&
-             ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) &&
-             ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -63144,48 +59428,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const &
-                            physicalDeviceShaderAtomicFloatFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderAtomicInt64Features
   {
     using NativeType = VkPhysicalDeviceShaderAtomicInt64Features;
@@ -63243,29 +59485,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>( this );
     }
 
-    operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) &&
-             ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -63292,27 +59545,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const &
-                            physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicInt64Features.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicInt64Features.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderClockFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderClockFeaturesKHR;
@@ -63369,28 +59601,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) &&
-             ( shaderDeviceClock == rhs.shaderDeviceClock );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -63415,27 +59659,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderClockFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const &
-                            physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderClockFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderClockFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderCoreProperties2AMD
   {
     using NativeType = VkPhysicalDeviceShaderCoreProperties2AMD;
@@ -63471,28 +59694,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>( this );
     }
 
-    operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) &&
-             ( activeComputeUnitCount == rhs.activeComputeUnitCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -63518,27 +59753,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderCoreProperties2AMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const &
-                            physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCoreProperties2AMD.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCoreProperties2AMD.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD,
-                             seed,
-                             physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderCorePropertiesAMD
   {
     using NativeType = VkPhysicalDeviceShaderCorePropertiesAMD;
@@ -63598,35 +59812,67 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>( this );
     }
 
-    operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       shaderEngineCount,
+                       shaderArraysPerEngineCount,
+                       computeUnitsPerShaderArray,
+                       simdPerComputeUnit,
+                       wavefrontsPerSimd,
+                       wavefrontSize,
+                       sgprsPerSimd,
+                       minSgprAllocation,
+                       maxSgprAllocation,
+                       sgprAllocationGranularity,
+                       vgprsPerSimd,
+                       minVgprAllocation,
+                       maxVgprAllocation,
+                       vgprAllocationGranularity );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEngineCount == rhs.shaderEngineCount ) &&
-             ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) &&
-             ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) &&
-             ( simdPerComputeUnit == rhs.simdPerComputeUnit ) && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) &&
-             ( wavefrontSize == rhs.wavefrontSize ) && ( sgprsPerSimd == rhs.sgprsPerSimd ) &&
-             ( minSgprAllocation == rhs.minSgprAllocation ) && ( maxSgprAllocation == rhs.maxSgprAllocation ) &&
-             ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) && ( vgprsPerSimd == rhs.vgprsPerSimd ) &&
-             ( minVgprAllocation == rhs.minVgprAllocation ) && ( maxVgprAllocation == rhs.maxVgprAllocation ) &&
-             ( vgprAllocationGranularity == rhs.vgprAllocationGranularity );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -63663,37 +59909,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderCorePropertiesAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const &
-                            physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCorePropertiesAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCorePropertiesAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
@@ -63745,28 +59960,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderDemoteToHelperInvocation );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -63792,27 +60016,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &
-                            physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.shaderDemoteToHelperInvocation );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderDrawParametersFeatures
   {
     using NativeType = VkPhysicalDeviceShaderDrawParametersFeatures;
@@ -63862,27 +60065,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderDrawParameters );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -63908,26 +60121,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const &
-                            physicalDeviceShaderDrawParametersFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDrawParametersFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDrawParametersFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderFloat16Int8Features
   {
     using NativeType = VkPhysicalDeviceShaderFloat16Int8Features;
@@ -63985,28 +60178,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>( this );
     }
 
-    operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderFloat16, shaderInt8 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) &&
-             ( shaderInt8 == rhs.shaderInt8 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -64034,26 +60239,6 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;
   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const &
-                            physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderFloat16Int8Features.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderFloat16Int8Features.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
@@ -64113,29 +60298,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) &&
-             ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -64161,28 +60357,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &
-                            physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderImageFootprintFeaturesNV
   {
     using NativeType = VkPhysicalDeviceShaderImageFootprintFeaturesNV;
@@ -64231,27 +60405,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imageFootprint );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -64276,26 +60460,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderImageFootprintFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const &
-                            physicalDeviceShaderImageFootprintFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageFootprintFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR;
@@ -64346,28 +60510,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderIntegerDotProduct );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -64392,26 +60565,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR const &
-                            physicalDeviceShaderIntegerDotProductFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.shaderIntegerDotProduct );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR
   {
     using NativeType = VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR;
@@ -64801,78 +60954,99 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       integerDotProduct8BitUnsignedAccelerated,
+                       integerDotProduct8BitSignedAccelerated,
+                       integerDotProduct8BitMixedSignednessAccelerated,
+                       integerDotProduct4x8BitPackedUnsignedAccelerated,
+                       integerDotProduct4x8BitPackedSignedAccelerated,
+                       integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+                       integerDotProduct16BitUnsignedAccelerated,
+                       integerDotProduct16BitSignedAccelerated,
+                       integerDotProduct16BitMixedSignednessAccelerated,
+                       integerDotProduct32BitUnsignedAccelerated,
+                       integerDotProduct32BitSignedAccelerated,
+                       integerDotProduct32BitMixedSignednessAccelerated,
+                       integerDotProduct64BitUnsignedAccelerated,
+                       integerDotProduct64BitSignedAccelerated,
+                       integerDotProduct64BitMixedSignednessAccelerated,
+                       integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+                       integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+                       integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+                       integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+                       integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+                       integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+                       integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+                       integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+                       integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+                       integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+                       integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+                       integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+                       integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+                       integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+                       integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) &&
-             ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) &&
-             ( integerDotProduct8BitMixedSignednessAccelerated ==
-               rhs.integerDotProduct8BitMixedSignednessAccelerated ) &&
-             ( integerDotProduct4x8BitPackedUnsignedAccelerated ==
-               rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) &&
-             ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) &&
-             ( integerDotProduct4x8BitPackedMixedSignednessAccelerated ==
-               rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) &&
-             ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) &&
-             ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) &&
-             ( integerDotProduct16BitMixedSignednessAccelerated ==
-               rhs.integerDotProduct16BitMixedSignednessAccelerated ) &&
-             ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) &&
-             ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) &&
-             ( integerDotProduct32BitMixedSignednessAccelerated ==
-               rhs.integerDotProduct32BitMixedSignednessAccelerated ) &&
-             ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) &&
-             ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) &&
-             ( integerDotProduct64BitMixedSignednessAccelerated ==
-               rhs.integerDotProduct64BitMixedSignednessAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating8BitSignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating16BitSignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating32BitSignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating64BitSignedAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) &&
-             ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ==
-               rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -64926,144 +61100,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR const &
-                            physicalDeviceShaderIntegerDotProductPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating16BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating32BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating64BitSignedAccelerated );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderIntegerDotProductPropertiesKHR
-                               .integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
   {
     using NativeType = VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
@@ -65115,28 +61151,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>( this );
     }
 
-    operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderIntegerFunctions2 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65161,26 +61206,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &
-                            physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
   {
     using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
@@ -65229,27 +61254,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderSMBuiltins );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65274,26 +61309,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const &
-                            physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
   {
     using NativeType = VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
@@ -65330,28 +61345,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>( this );
     }
 
-    operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) &&
-             ( shaderWarpsPerSM == rhs.shaderWarpsPerSM );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65377,26 +61401,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const &
-                            physicalDeviceShaderSMBuiltinsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures
   {
     using NativeType = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
@@ -65448,28 +61452,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderSubgroupExtendedTypes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65495,27 +61508,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const &
-                            physicalDeviceShaderSubgroupExtendedTypesFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
@@ -65569,28 +61561,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderSubgroupUniformControlFlow );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65617,28 +61618,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
-                            physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;
@@ -65690,28 +61669,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderTerminateInvocation );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderTerminateInvocation == rhs.shaderTerminateInvocation );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65736,27 +61724,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR const &
-                            physicalDeviceShaderTerminateInvocationFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceShaderTerminateInvocationFeaturesKHR.shaderTerminateInvocation );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShadingRateImageFeaturesNV
   {
     using NativeType = VkPhysicalDeviceShadingRateImageFeaturesNV;
@@ -65815,28 +61782,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>( this );
     }
 
-    operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) &&
-             ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65862,28 +61841,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShadingRateImageFeaturesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const &
-                            physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImageFeaturesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImageFeaturesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceShadingRateImagePropertiesNV
   {
     using NativeType = VkPhysicalDeviceShadingRateImagePropertiesNV;
@@ -65922,29 +61879,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV *>( this );
     }
 
-    operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) &&
-             ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) &&
-             ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -65971,28 +61940,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShadingRateImagePropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const &
-                            physicalDeviceShadingRateImagePropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImagePropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImagePropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSparseImageFormatInfo2
   {
     using NativeType = VkPhysicalDeviceSparseImageFormatInfo2;
@@ -66076,28 +62023,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( this );
     }
 
-    operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::ImageType const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+               VULKAN_HPP_NAMESPACE::ImageTiling const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, format, type, samples, usage, tiling );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) &&
-             ( samples == rhs.samples ) && ( usage == rhs.usage ) && ( tiling == rhs.tiling );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66126,29 +62088,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const &
-                            physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSparseImageFormatInfo2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSparseImageFormatInfo2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceSparseImageFormatInfo2.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceSparseImageFormatInfo2.type );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, physicalDeviceSparseImageFormatInfo2.samples );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceSparseImageFormatInfo2.usage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceSparseImageFormatInfo2.tiling );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSubgroupProperties
   {
     using NativeType = VkPhysicalDeviceSubgroupProperties;
@@ -66185,29 +62124,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>( this );
     }
 
-    operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+               VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) &&
-             ( supportedStages == rhs.supportedStages ) && ( supportedOperations == rhs.supportedOperations ) &&
-             ( quadOperationsInAllStages == rhs.quadOperationsInAllStages );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66234,31 +62186,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubgroupProperties;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupProperties.subgroupSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceSubgroupProperties.supportedStages );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceSubgroupProperties.supportedOperations );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSubgroupSizeControlFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
@@ -66317,28 +62244,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) &&
-             ( computeFullSubgroups == rhs.computeFullSubgroups );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66364,28 +62303,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubgroupSizeControlFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT const &
-                            physicalDeviceSubgroupSizeControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.subgroupSizeControl );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.computeFullSubgroups );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
@@ -66426,30 +62343,43 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ShaderStageFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) &&
-             ( maxSubgroupSize == rhs.maxSubgroupSize ) &&
-             ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) &&
-             ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66477,31 +62407,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubgroupSizeControlPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT const &
-                            physicalDeviceSubgroupSizeControlPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.minSubgroupSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxSubgroupSize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxComputeWorkgroupSubgroups );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags,
-                             seed,
-                             physicalDeviceSubgroupSizeControlPropertiesEXT.requiredSubgroupSizeStages );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI
   {
     using NativeType = VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;
@@ -66550,27 +62455,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>( this );
     }
 
-    operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, subpassShading );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66595,26 +62510,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const &
-                            physicalDeviceSubpassShadingFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI
   {
     using NativeType = VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;
@@ -66649,28 +62544,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>( this );
     }
 
-    operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66695,26 +62599,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const &
-                            physicalDeviceSubpassShadingPropertiesHUAWEI ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSurfaceInfo2KHR
   {
     using NativeType = VkPhysicalDeviceSurfaceInfo2KHR;
@@ -66760,27 +62644,38 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( this );
     }
 
-    operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::SurfaceKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, surface );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66804,24 +62699,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSurfaceInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSurfaceInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSurfaceInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, physicalDeviceSurfaceInfo2KHR.surface );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceSynchronization2FeaturesKHR
   {
     using NativeType = VkPhysicalDeviceSynchronization2FeaturesKHR;
@@ -66870,27 +62747,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceSynchronization2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSynchronization2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceSynchronization2FeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceSynchronization2FeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, synchronization2 );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSynchronization2FeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -66915,26 +62802,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSynchronization2FeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR const &
-                            physicalDeviceSynchronization2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSynchronization2FeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSynchronization2FeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSynchronization2FeaturesKHR.synchronization2 );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
@@ -66985,27 +62852,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, texelBufferAlignment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67030,26 +62907,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const &
-                            physicalDeviceTexelBufferAlignmentFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
@@ -67090,31 +62947,47 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       storageTexelBufferOffsetAlignmentBytes,
+                       storageTexelBufferOffsetSingleTexelAlignment,
+                       uniformTexelBufferOffsetAlignmentBytes,
+                       uniformTexelBufferOffsetSingleTexelAlignment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) &&
-             ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) &&
-             ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) &&
-             ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67142,38 +63015,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const &
-                            physicalDeviceTexelBufferAlignmentPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
-                             seed,
-                             physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetAlignmentBytes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetSingleTexelAlignment );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
-                             seed,
-                             physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetAlignmentBytes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetSingleTexelAlignment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
@@ -67225,28 +63066,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, textureCompressionASTC_HDR );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67271,27 +63121,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &
-                            physicalDeviceTextureCompressionASTCHDRFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceTextureCompressionASTCHDRFeaturesEXT.textureCompressionASTC_HDR );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceTimelineSemaphoreFeatures
   {
     using NativeType = VkPhysicalDeviceTimelineSemaphoreFeatures;
@@ -67339,27 +63168,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, timelineSemaphore );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67385,25 +63224,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const &
-                            physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceTimelineSemaphoreProperties
   {
     using NativeType = VkPhysicalDeviceTimelineSemaphoreProperties;
@@ -67437,28 +63257,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties *>( this );
     }
 
-    operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67484,26 +63313,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const &
-                            physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint64_t, seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceToolPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceToolPropertiesEXT;
@@ -67542,28 +63351,43 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceToolPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceToolPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceToolPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceToolPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceToolPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, name, version, purposes, description, layer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceToolPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) &&
-             ( purposes == rhs.purposes ) && ( description == rhs.description ) && ( layer == rhs.layer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67591,42 +63415,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceToolPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT const & physicalDeviceToolPropertiesEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceToolPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceToolPropertiesEXT.pNext );
-    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.name[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.version[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT, seed, physicalDeviceToolPropertiesEXT.purposes );
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.description[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.layer[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceTransformFeedbackFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceTransformFeedbackFeaturesEXT;
@@ -67685,28 +63473,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, transformFeedback, geometryStreams );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) &&
-             ( geometryStreams == rhs.geometryStreams );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67732,28 +63532,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTransformFeedbackFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const &
-                            physicalDeviceTransformFeedbackFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceTransformFeedbackPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceTransformFeedbackPropertiesEXT;
@@ -67806,37 +63584,59 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       maxTransformFeedbackStreams,
+                       maxTransformFeedbackBuffers,
+                       maxTransformFeedbackBufferSize,
+                       maxTransformFeedbackStreamDataSize,
+                       maxTransformFeedbackBufferDataSize,
+                       maxTransformFeedbackBufferDataStride,
+                       transformFeedbackQueries,
+                       transformFeedbackStreamsLinesTriangles,
+                       transformFeedbackRasterizationStreamSelect,
+                       transformFeedbackDraw );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) &&
-             ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers ) &&
-             ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize ) &&
-             ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize ) &&
-             ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize ) &&
-             ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride ) &&
-             ( transformFeedbackQueries == rhs.transformFeedbackQueries ) &&
-             ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles ) &&
-             ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect ) &&
-             ( transformFeedbackDraw == rhs.transformFeedbackDraw );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -67870,45 +63670,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTransformFeedbackPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const &
-                            physicalDeviceTransformFeedbackPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
-                             seed,
-                             physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceUniformBufferStandardLayoutFeatures
   {
     using NativeType = VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
@@ -67960,28 +63721,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, uniformBufferStandardLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -68007,27 +63777,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const &
-                            physicalDeviceUniformBufferStandardLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVariablePointersFeatures
   {
     using NativeType = VkPhysicalDeviceVariablePointersFeatures;
@@ -68085,29 +63834,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) &&
-             ( variablePointers == rhs.variablePointers );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -68136,27 +63896,6 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;
   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const &
-                            physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVariablePointersFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVariablePointersFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointers );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
@@ -68216,29 +63955,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) &&
-             ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -68264,30 +64014,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const &
-                            physicalDeviceVertexAttributeDivisorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
@@ -68323,28 +64049,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxVertexAttribDivisor );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -68369,25 +64104,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const &
-                            physicalDeviceVertexAttributeDivisorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;
@@ -68438,28 +64154,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, vertexInputDynamicState );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( vertexInputDynamicState == rhs.vertexInputDynamicState );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -68484,26 +64209,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const &
-                            physicalDeviceVertexInputDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   struct VideoProfileKHR
   {
@@ -68576,29 +64281,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoProfileKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoProfileKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoProfileKHR *>( this );
     }
 
-    operator VkVideoProfileKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoProfileKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoProfileKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoProfileKHR const & ) const = default;
 #  else
     bool operator==( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) &&
-             ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) &&
-             ( chromaBitDepth == rhs.chromaBitDepth );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -68623,30 +64341,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoProfileKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoProfileKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileKHR const & videoProfileKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfileKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfileKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR, seed, videoProfileKHR.videoCodecOperation );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR, seed, videoProfileKHR.chromaSubsampling );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.lumaBitDepth );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.chromaBitDepth );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -68701,28 +64395,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoProfilesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoProfilesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoProfilesKHR *>( this );
     }
 
-    operator VkVideoProfilesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoProfilesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoProfilesKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoProfileKHR * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, profileCount, pProfiles );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoProfilesKHR const & ) const = default;
 #  else
     bool operator==( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) &&
-             ( pProfiles == rhs.pProfiles );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -68744,25 +64450,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoProfilesKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoProfilesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfilesKHR const & videoProfilesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfilesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfilesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoProfilesKHR.profileCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoProfilesKHR.pProfiles );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -68798,28 +64485,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( this );
     }
 
-    operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVideoFormatInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+               const VULKAN_HPP_NAMESPACE::VideoProfilesKHR * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imageUsage, pVideoProfiles );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default;
 #  else
     bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ) &&
-             ( pVideoProfiles == rhs.pVideoProfiles );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -68843,28 +64542,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PhysicalDeviceVideoFormatInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVideoFormatInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVideoFormatInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceVideoFormatInfoKHR.imageUsage );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoProfilesKHR *, seed, physicalDeviceVideoFormatInfoKHR.pVideoProfiles );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct PhysicalDeviceVulkan11Features
@@ -69011,37 +64688,63 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>( this );
     }
 
-    operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVulkan11Features *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       storageBuffer16BitAccess,
+                       uniformAndStorageBuffer16BitAccess,
+                       storagePushConstant16,
+                       storageInputOutput16,
+                       multiview,
+                       multiviewGeometryShader,
+                       multiviewTessellationShader,
+                       variablePointersStorageBuffer,
+                       variablePointers,
+                       protectedMemory,
+                       samplerYcbcrConversion,
+                       shaderDrawParameters );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) &&
-             ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) &&
-             ( storagePushConstant16 == rhs.storagePushConstant16 ) &&
-             ( storageInputOutput16 == rhs.storageInputOutput16 ) && ( multiview == rhs.multiview ) &&
-             ( multiviewGeometryShader == rhs.multiviewGeometryShader ) &&
-             ( multiviewTessellationShader == rhs.multiviewTessellationShader ) &&
-             ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) &&
-             ( variablePointers == rhs.variablePointers ) && ( protectedMemory == rhs.protectedMemory ) &&
-             ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ) &&
-             ( shaderDrawParameters == rhs.shaderDrawParameters );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -69076,41 +64779,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan11Features;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Features.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Features.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storagePushConstant16 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageInputOutput16 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiview );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewGeometryShader );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewTessellationShader );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointers );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.protectedMemory );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.samplerYcbcrConversion );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.shaderDrawParameters );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVulkan11Properties
   {
     using NativeType = VkPhysicalDeviceVulkan11Properties;
@@ -69170,37 +64838,69 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan11Properties *>( this );
     }
 
-    operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVulkan11Properties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+               VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::PointClippingBehavior const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       deviceUUID,
+                       driverUUID,
+                       deviceLUID,
+                       deviceNodeMask,
+                       deviceLUIDValid,
+                       subgroupSize,
+                       subgroupSupportedStages,
+                       subgroupSupportedOperations,
+                       subgroupQuadOperationsInAllStages,
+                       pointClippingBehavior,
+                       maxMultiviewViewCount,
+                       maxMultiviewInstanceIndex,
+                       protectedNoFault,
+                       maxPerSetDescriptors,
+                       maxMemoryAllocationSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) &&
-             ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) &&
-             ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ) &&
-             ( subgroupSize == rhs.subgroupSize ) && ( subgroupSupportedStages == rhs.subgroupSupportedStages ) &&
-             ( subgroupSupportedOperations == rhs.subgroupSupportedOperations ) &&
-             ( subgroupQuadOperationsInAllStages == rhs.subgroupQuadOperationsInAllStages ) &&
-             ( pointClippingBehavior == rhs.pointClippingBehavior ) &&
-             ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) &&
-             ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ) &&
-             ( protectedNoFault == rhs.protectedNoFault ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) &&
-             ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -69239,53 +64939,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan11Properties;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Properties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Properties.pNext );
-    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceUUID[i] );
-    }
-    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.driverUUID[i] );
-    }
-    for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceLUID[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.deviceNodeMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.deviceLUIDValid );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.subgroupSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedStages );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDeviceVulkan11Properties.pointClippingBehavior );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.protectedNoFault );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVulkan12Features
   {
     using NativeType = VkPhysicalDeviceVulkan12Features;
@@ -69745,74 +65398,133 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>( this );
     }
 
-    operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVulkan12Features *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       samplerMirrorClampToEdge,
+                       drawIndirectCount,
+                       storageBuffer8BitAccess,
+                       uniformAndStorageBuffer8BitAccess,
+                       storagePushConstant8,
+                       shaderBufferInt64Atomics,
+                       shaderSharedInt64Atomics,
+                       shaderFloat16,
+                       shaderInt8,
+                       descriptorIndexing,
+                       shaderInputAttachmentArrayDynamicIndexing,
+                       shaderUniformTexelBufferArrayDynamicIndexing,
+                       shaderStorageTexelBufferArrayDynamicIndexing,
+                       shaderUniformBufferArrayNonUniformIndexing,
+                       shaderSampledImageArrayNonUniformIndexing,
+                       shaderStorageBufferArrayNonUniformIndexing,
+                       shaderStorageImageArrayNonUniformIndexing,
+                       shaderInputAttachmentArrayNonUniformIndexing,
+                       shaderUniformTexelBufferArrayNonUniformIndexing,
+                       shaderStorageTexelBufferArrayNonUniformIndexing,
+                       descriptorBindingUniformBufferUpdateAfterBind,
+                       descriptorBindingSampledImageUpdateAfterBind,
+                       descriptorBindingStorageImageUpdateAfterBind,
+                       descriptorBindingStorageBufferUpdateAfterBind,
+                       descriptorBindingUniformTexelBufferUpdateAfterBind,
+                       descriptorBindingStorageTexelBufferUpdateAfterBind,
+                       descriptorBindingUpdateUnusedWhilePending,
+                       descriptorBindingPartiallyBound,
+                       descriptorBindingVariableDescriptorCount,
+                       runtimeDescriptorArray,
+                       samplerFilterMinmax,
+                       scalarBlockLayout,
+                       imagelessFramebuffer,
+                       uniformBufferStandardLayout,
+                       shaderSubgroupExtendedTypes,
+                       separateDepthStencilLayouts,
+                       hostQueryReset,
+                       timelineSemaphore,
+                       bufferDeviceAddress,
+                       bufferDeviceAddressCaptureReplay,
+                       bufferDeviceAddressMultiDevice,
+                       vulkanMemoryModel,
+                       vulkanMemoryModelDeviceScope,
+                       vulkanMemoryModelAvailabilityVisibilityChains,
+                       shaderOutputViewportIndex,
+                       shaderOutputLayer,
+                       subgroupBroadcastDynamicId );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( samplerMirrorClampToEdge == rhs.samplerMirrorClampToEdge ) &&
-             ( drawIndirectCount == rhs.drawIndirectCount ) &&
-             ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) &&
-             ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) &&
-             ( storagePushConstant8 == rhs.storagePushConstant8 ) &&
-             ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) &&
-             ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ) && ( shaderFloat16 == rhs.shaderFloat16 ) &&
-             ( shaderInt8 == rhs.shaderInt8 ) && ( descriptorIndexing == rhs.descriptorIndexing ) &&
-             ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) &&
-             ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) &&
-             ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) &&
-             ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) &&
-             ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) &&
-             ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) &&
-             ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) &&
-             ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) &&
-             ( shaderUniformTexelBufferArrayNonUniformIndexing ==
-               rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) &&
-             ( shaderStorageTexelBufferArrayNonUniformIndexing ==
-               rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) &&
-             ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) &&
-             ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) &&
-             ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) &&
-             ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) &&
-             ( descriptorBindingUniformTexelBufferUpdateAfterBind ==
-               rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) &&
-             ( descriptorBindingStorageTexelBufferUpdateAfterBind ==
-               rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) &&
-             ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) &&
-             ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) &&
-             ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) &&
-             ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ) &&
-             ( samplerFilterMinmax == rhs.samplerFilterMinmax ) && ( scalarBlockLayout == rhs.scalarBlockLayout ) &&
-             ( imagelessFramebuffer == rhs.imagelessFramebuffer ) &&
-             ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ) &&
-             ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ) &&
-             ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ) &&
-             ( hostQueryReset == rhs.hostQueryReset ) && ( timelineSemaphore == rhs.timelineSemaphore ) &&
-             ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
-             ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
-             ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ) &&
-             ( vulkanMemoryModel == rhs.vulkanMemoryModel ) &&
-             ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) &&
-             ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ) &&
-             ( shaderOutputViewportIndex == rhs.shaderOutputViewportIndex ) &&
-             ( shaderOutputLayer == rhs.shaderOutputLayer ) &&
-             ( subgroupBroadcastDynamicId == rhs.subgroupBroadcastDynamicId );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -69882,111 +65594,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan12Features;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Features.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Features.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.drawIndirectCount );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storagePushConstant8 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderFloat16 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInt8 );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.runtimeDescriptorArray );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerFilterMinmax );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.scalarBlockLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.imagelessFramebuffer );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.hostQueryReset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.timelineSemaphore );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddress );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModel );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputLayer );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVulkan12Properties
   {
     using NativeType = VkPhysicalDeviceVulkan12Properties;
@@ -70121,90 +65728,143 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan12Properties *>( this );
     }
 
-    operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVulkan12Properties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::DriverId const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ConformanceVersion const &,
+               VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+               VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+               VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::SampleCountFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       driverID,
+                       driverName,
+                       driverInfo,
+                       conformanceVersion,
+                       denormBehaviorIndependence,
+                       roundingModeIndependence,
+                       shaderSignedZeroInfNanPreserveFloat16,
+                       shaderSignedZeroInfNanPreserveFloat32,
+                       shaderSignedZeroInfNanPreserveFloat64,
+                       shaderDenormPreserveFloat16,
+                       shaderDenormPreserveFloat32,
+                       shaderDenormPreserveFloat64,
+                       shaderDenormFlushToZeroFloat16,
+                       shaderDenormFlushToZeroFloat32,
+                       shaderDenormFlushToZeroFloat64,
+                       shaderRoundingModeRTEFloat16,
+                       shaderRoundingModeRTEFloat32,
+                       shaderRoundingModeRTEFloat64,
+                       shaderRoundingModeRTZFloat16,
+                       shaderRoundingModeRTZFloat32,
+                       shaderRoundingModeRTZFloat64,
+                       maxUpdateAfterBindDescriptorsInAllPools,
+                       shaderUniformBufferArrayNonUniformIndexingNative,
+                       shaderSampledImageArrayNonUniformIndexingNative,
+                       shaderStorageBufferArrayNonUniformIndexingNative,
+                       shaderStorageImageArrayNonUniformIndexingNative,
+                       shaderInputAttachmentArrayNonUniformIndexingNative,
+                       robustBufferAccessUpdateAfterBind,
+                       quadDivergentImplicitLod,
+                       maxPerStageDescriptorUpdateAfterBindSamplers,
+                       maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+                       maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+                       maxPerStageDescriptorUpdateAfterBindSampledImages,
+                       maxPerStageDescriptorUpdateAfterBindStorageImages,
+                       maxPerStageDescriptorUpdateAfterBindInputAttachments,
+                       maxPerStageUpdateAfterBindResources,
+                       maxDescriptorSetUpdateAfterBindSamplers,
+                       maxDescriptorSetUpdateAfterBindUniformBuffers,
+                       maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+                       maxDescriptorSetUpdateAfterBindStorageBuffers,
+                       maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+                       maxDescriptorSetUpdateAfterBindSampledImages,
+                       maxDescriptorSetUpdateAfterBindStorageImages,
+                       maxDescriptorSetUpdateAfterBindInputAttachments,
+                       supportedDepthResolveModes,
+                       supportedStencilResolveModes,
+                       independentResolveNone,
+                       independentResolve,
+                       filterMinmaxSingleComponentFormats,
+                       filterMinmaxImageComponentMapping,
+                       maxTimelineSemaphoreValueDifference,
+                       framebufferIntegerColorSampleCounts );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan12Properties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) &&
-             ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) &&
-             ( conformanceVersion == rhs.conformanceVersion ) &&
-             ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) &&
-             ( roundingModeIndependence == rhs.roundingModeIndependence ) &&
-             ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) &&
-             ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) &&
-             ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) &&
-             ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) &&
-             ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) &&
-             ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) &&
-             ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) &&
-             ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) &&
-             ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) &&
-             ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) &&
-             ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) &&
-             ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) &&
-             ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) &&
-             ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) &&
-             ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ) &&
-             ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) &&
-             ( shaderUniformBufferArrayNonUniformIndexingNative ==
-               rhs.shaderUniformBufferArrayNonUniformIndexingNative ) &&
-             ( shaderSampledImageArrayNonUniformIndexingNative ==
-               rhs.shaderSampledImageArrayNonUniformIndexingNative ) &&
-             ( shaderStorageBufferArrayNonUniformIndexingNative ==
-               rhs.shaderStorageBufferArrayNonUniformIndexingNative ) &&
-             ( shaderStorageImageArrayNonUniformIndexingNative ==
-               rhs.shaderStorageImageArrayNonUniformIndexingNative ) &&
-             ( shaderInputAttachmentArrayNonUniformIndexingNative ==
-               rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) &&
-             ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) &&
-             ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) &&
-             ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) &&
-             ( maxPerStageDescriptorUpdateAfterBindUniformBuffers ==
-               rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) &&
-             ( maxPerStageDescriptorUpdateAfterBindStorageBuffers ==
-               rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) &&
-             ( maxPerStageDescriptorUpdateAfterBindSampledImages ==
-               rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) &&
-             ( maxPerStageDescriptorUpdateAfterBindStorageImages ==
-               rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) &&
-             ( maxPerStageDescriptorUpdateAfterBindInputAttachments ==
-               rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) &&
-             ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) &&
-             ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) &&
-             ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) &&
-             ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ==
-               rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) &&
-             ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) &&
-             ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ==
-               rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) &&
-             ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) &&
-             ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) &&
-             ( maxDescriptorSetUpdateAfterBindInputAttachments ==
-               rhs.maxDescriptorSetUpdateAfterBindInputAttachments ) &&
-             ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) &&
-             ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) &&
-             ( independentResolveNone == rhs.independentResolveNone ) &&
-             ( independentResolve == rhs.independentResolve ) &&
-             ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) &&
-             ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ) &&
-             ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ) &&
-             ( framebufferIntegerColorSampleCounts == rhs.framebufferIntegerColorSampleCounts );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -70281,134 +65941,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan12Properties;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Properties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Properties.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceVulkan12Properties.driverID );
-    for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverName[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverInfo[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceVulkan12Properties.conformanceVersion );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
-                             seed,
-                             physicalDeviceVulkan12Properties.denormBehaviorIndependence );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
-                             seed,
-                             physicalDeviceVulkan12Properties.roundingModeIndependence );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolveNone );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolve );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags,
-                             seed,
-                             physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceVulkanMemoryModelFeatures
   {
     using NativeType = VkPhysicalDeviceVulkanMemoryModelFeatures;
@@ -70475,29 +66007,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>( this );
     }
 
-    operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) &&
-             ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) &&
-             ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -70525,30 +66070,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const &
-                            physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkanMemoryModelFeatures.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkanMemoryModelFeatures.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
@@ -70630,31 +66151,47 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       workgroupMemoryExplicitLayout,
+                       workgroupMemoryExplicitLayoutScalarBlockLayout,
+                       workgroupMemoryExplicitLayout8BitAccess,
+                       workgroupMemoryExplicitLayout16BitAccess );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) &&
-             ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) &&
-             ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) &&
-             ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -70683,39 +66220,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &
-                            physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
@@ -70766,27 +66270,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, ycbcr2plane444Formats );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -70811,26 +66325,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &
-                            physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
@@ -70879,27 +66373,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>( this );
     }
 
-    operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, ycbcrImageArrays );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -70924,26 +66428,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const &
-                            physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
@@ -70996,28 +66480,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -71043,28 +66536,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &
-                            physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32,
-      seed,
-      physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.shaderZeroInitializeWorkgroupMemory );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCacheCreateInfo
   {
     using NativeType = VkPipelineCacheCreateInfo;
@@ -71142,28 +66613,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCacheCreateInfo *>( this );
     }
 
-    operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCacheCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags const &,
+               size_t const &,
+               const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCacheCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -71188,26 +66672,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCacheCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCacheCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags, seed, pipelineCacheCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineCacheCreateInfo.initialDataSize );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pInitialData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCacheHeaderVersionOne
   {
     using NativeType = VkPipelineCacheHeaderVersionOne;
@@ -71278,29 +66742,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCacheHeaderVersionOne *>( this );
     }
 
-    operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCacheHeaderVersionOne *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default;
 #else
     bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) &&
-             ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) &&
-             ( pipelineCacheUUID == rhs.pipelineCacheUUID );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -71321,30 +66797,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>::value,
     "PipelineCacheHeaderVersionOne is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.headerSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion, seed, pipelineCacheHeaderVersionOne.headerVersion );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.vendorID );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.deviceID );
-    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineColorBlendAdvancedStateCreateInfoEXT
   {
     using NativeType = VkPipelineColorBlendAdvancedStateCreateInfoEXT;
@@ -71414,28 +66866,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::BlendOverlapEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) &&
-             ( dstPremultiplied == rhs.dstPremultiplied ) && ( blendOverlap == rhs.blendOverlap );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -71462,30 +66927,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineColorBlendAdvancedStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const &
-                            pipelineColorBlendAdvancedStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::BlendOverlapEXT, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineColorWriteCreateInfoEXT
   {
     using NativeType = VkPipelineColorWriteCreateInfoEXT;
@@ -71559,28 +67000,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineColorWriteCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Bool32 * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, attachmentCount, pColorWriteEnables );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) &&
-             ( pColorWriteEnables == rhs.pColorWriteEnables );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -71605,27 +67058,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineColorWriteCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorWriteCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorWriteCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorWriteCreateInfoEXT.attachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Bool32 *, seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCompilerControlCreateInfoAMD
   {
     using NativeType = VkPipelineCompilerControlCreateInfoAMD;
@@ -71673,27 +67105,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD *>( this );
     }
 
-    operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, compilerControlFlags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default;
 #else
     bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -71717,26 +67161,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCompilerControlCreateInfoAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const &
-                            pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCompilerControlCreateInfoAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCompilerControlCreateInfoAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD,
-                             seed,
-                             pipelineCompilerControlCreateInfoAMD.compilerControlFlags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCoverageModulationStateCreateInfoNV
   {
     using NativeType = VkPipelineCoverageModulationStateCreateInfoNV;
@@ -71848,31 +67272,49 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV const &,
+               VULKAN_HPP_NAMESPACE::CoverageModulationModeNV const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               const float * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       coverageModulationMode,
+                       coverageModulationTableEnable,
+                       coverageModulationTableCount,
+                       pCoverageModulationTable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( coverageModulationMode == rhs.coverageModulationMode ) &&
-             ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) &&
-             ( coverageModulationTableCount == rhs.coverageModulationTableCount ) &&
-             ( pCoverageModulationTable == rhs.pCoverageModulationTable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -71902,35 +67344,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCoverageModulationStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const &
-                            pipelineCoverageModulationStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageModulationStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageModulationStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV,
-                             seed,
-                             pipelineCoverageModulationStateCreateInfoNV.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV,
-                             seed,
-                             pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const float *, seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCoverageReductionStateCreateInfoNV
   {
     using NativeType = VkPipelineCoverageReductionStateCreateInfoNV;
@@ -71991,28 +67404,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV const &,
+               VULKAN_HPP_NAMESPACE::CoverageReductionModeNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, coverageReductionMode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( coverageReductionMode == rhs.coverageReductionMode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72039,30 +67464,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCoverageReductionStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const &
-                            pipelineCoverageReductionStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageReductionStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageReductionStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV,
-                             seed,
-                             pipelineCoverageReductionStateCreateInfoNV.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV,
-                             seed,
-                             pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCoverageToColorStateCreateInfoNV
   {
     using NativeType = VkPipelineCoverageToColorStateCreateInfoNV;
@@ -72131,29 +67532,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( coverageToColorEnable == rhs.coverageToColorEnable ) &&
-             ( coverageToColorLocation == rhs.coverageToColorLocation );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72180,30 +67593,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCoverageToColorStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const &
-                            pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageToColorStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageToColorStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV,
-                             seed,
-                             pipelineCoverageToColorStateCreateInfoNV.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCreationFeedbackEXT
   {
     using NativeType = VkPipelineCreationFeedbackEXT;
@@ -72232,27 +67621,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPipelineCreationFeedbackEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCreationFeedbackEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCreationFeedbackEXT *>( this );
     }
 
-    operator VkPipelineCreationFeedbackEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCreationFeedbackEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCreationFeedbackEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( flags, duration );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCreationFeedbackEXT const & ) const = default;
 #else
     bool operator==( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( flags == rhs.flags ) && ( duration == rhs.duration );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72269,24 +67668,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT>::value,
     "PipelineCreationFeedbackEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT const & pipelineCreationFeedbackEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT, seed, pipelineCreationFeedbackEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pipelineCreationFeedbackEXT.duration );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineCreationFeedbackCreateInfoEXT
   {
     using NativeType = VkPipelineCreationFeedbackCreateInfoEXT;
@@ -72375,30 +67756,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) &&
-             ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) &&
-             ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72424,30 +67817,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCreationFeedbackCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT const &
-                            pipelineCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCreationFeedbackCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCreationFeedbackCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *,
-                             seed,
-                             pipelineCreationFeedbackCreateInfoEXT.pPipelineCreationFeedback );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCreationFeedbackCreateInfoEXT.pipelineStageCreationFeedbackCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *,
-                             seed,
-                             pipelineCreationFeedbackCreateInfoEXT.pPipelineStageCreationFeedbacks );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineDiscardRectangleStateCreateInfoEXT
   {
     using NativeType = VkPipelineDiscardRectangleStateCreateInfoEXT;
@@ -72549,29 +67918,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( discardRectangleMode == rhs.discardRectangleMode ) &&
-             ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72600,33 +67982,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineDiscardRectangleStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const &
-                            pipelineDiscardRectangleStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDiscardRectangleStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT,
-                             seed,
-                             pipelineDiscardRectangleStateCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT,
-                             seed,
-                             pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineExecutableInfoKHR
   {
     using NativeType = VkPipelineExecutableInfoKHR;
@@ -72679,28 +68034,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutableInfoKHR *>( this );
     }
 
-    operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineExecutableInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Pipeline const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pipeline, executableIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineExecutableInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) &&
-             ( executableIndex == rhs.executableIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72724,25 +68091,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineExecutableInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineExecutableInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineExecutableInfoKHR.pipeline );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutableInfoKHR.executableIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineExecutableInternalRepresentationKHR
   {
     using NativeType = VkPipelineExecutableInternalRepresentationKHR;
@@ -72799,29 +68147,43 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR *>( this );
     }
 
-    operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               size_t const &,
+               void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, name, description, isText, dataSize, pData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineExecutableInternalRepresentationKHR const & ) const = default;
 #else
     bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) &&
-             ( description == rhs.description ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) &&
-             ( pData == rhs.pData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72850,35 +68212,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineExecutableInternalRepresentationKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const &
-                            pipelineExecutableInternalRepresentationKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInternalRepresentationKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pNext );
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.name[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.description[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineExecutableInternalRepresentationKHR.isText );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineExecutableInternalRepresentationKHR.dataSize );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineExecutablePropertiesKHR
   {
     using NativeType = VkPipelineExecutablePropertiesKHR;
@@ -72915,28 +68248,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutablePropertiesKHR *>( this );
     }
 
-    operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stages, name, description, subgroupSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineExecutablePropertiesKHR const & ) const = default;
 #else
     bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) &&
-             ( description == rhs.description ) && ( subgroupSize == rhs.subgroupSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -72963,34 +68310,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineExecutablePropertiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutablePropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutablePropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pipelineExecutablePropertiesKHR.stages );
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.name[i] );
-    }
-    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.description[i] );
-    }
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutablePropertiesKHR.subgroupSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   union PipelineExecutableStatisticValueKHR
   {
     using NativeType = VkPipelineExecutableStatisticValueKHR;
@@ -73093,16 +68412,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutableStatisticKHR *>( this );
     }
 
-    operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineExecutableStatisticKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+               VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR const &,
+               VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, name, description, format, value );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR;
     void *                              pNext = {};
@@ -73199,28 +68533,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV const &,
+               VULKAN_HPP_NAMESPACE::FragmentShadingRateNV const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, 2> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineFragmentShadingRateEnumStateCreateInfoNV const & ) const = default;
 #else
-    bool     operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) &&
-             ( shadingRate == rhs.shadingRate ) && ( combinerOps == rhs.combinerOps );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -73249,35 +68596,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const &
-                            pipelineFragmentShadingRateEnumStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV,
-                             seed,
-                             pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FragmentShadingRateNV, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR,
-                               seed,
-                               pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineFragmentShadingRateStateCreateInfoKHR
   {
     using NativeType = VkPipelineFragmentShadingRateStateCreateInfoKHR;
@@ -73339,28 +68657,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR *>( this );
     }
 
-    operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, 2> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fragmentSize, combinerOps );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) &&
-             ( combinerOps == rhs.combinerOps );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -73386,32 +68716,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineFragmentShadingRateStateCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const &
-                            pipelineFragmentShadingRateStateCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize );
-    for ( size_t i = 0; i < 2; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR,
-                               seed,
-                               pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineInfoKHR
   {
     using NativeType = VkPipelineInfoKHR;
@@ -73454,27 +68758,38 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineInfoKHR *>( this );
     }
 
-    operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Pipeline const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pipeline );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -73496,23 +68811,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineInfoKHR.pipeline );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PushConstantRange
   {
     using NativeType = VkPushConstantRange;
@@ -73562,27 +68860,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPushConstantRange *>( this );
     }
 
-    operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPushConstantRange *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ShaderStageFlags const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( stageFlags, offset, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PushConstantRange const & ) const = default;
 #else
     bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -73598,23 +68906,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PushConstantRange>::value,
                             "PushConstantRange is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PushConstantRange>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pushConstantRange.stageFlags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.offset );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineLayoutCreateInfo
   {
     using NativeType = VkPipelineLayoutCreateInfo;
@@ -73730,30 +69021,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineLayoutCreateInfo *>( this );
     }
 
-    operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineLayoutCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PushConstantRange * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineLayoutCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ) &&
-             ( pushConstantRangeCount == rhs.pushConstantRangeCount ) &&
-             ( pPushConstantRanges == rhs.pPushConstantRanges );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -73780,30 +69084,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineLayoutCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLayoutCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLayoutCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags, seed, pipelineLayoutCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.setLayoutCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, pipelineLayoutCreateInfo.pSetLayouts );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.pushConstantRangeCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PushConstantRange *, seed, pipelineLayoutCreateInfo.pPushConstantRanges );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineLibraryCreateInfoKHR
   {
     using NativeType = VkPipelineLibraryCreateInfoKHR;
@@ -73874,28 +69154,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineLibraryCreateInfoKHR *>( this );
     }
 
-    operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineLibraryCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Pipeline * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, libraryCount, pLibraries );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) &&
-             ( pLibraries == rhs.pLibraries );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -73920,25 +69212,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineLibraryCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLibraryCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLibraryCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLibraryCreateInfoKHR.libraryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Pipeline *, seed, pipelineLibraryCreateInfoKHR.pLibraries );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRasterizationConservativeStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationConservativeStateCreateInfoEXT;
@@ -74009,29 +69282,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT const &,
+               float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) &&
-             ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -74059,32 +69344,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationConservativeStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const &
-                            pipelineRasterizationConservativeStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT,
-                             seed,
-                             pipelineRasterizationConservativeStateCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT,
-                             seed,
-                             pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode );
-    VULKAN_HPP_HASH_COMBINE(
-      float, seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRasterizationDepthClipStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationDepthClipStateCreateInfoEXT;
@@ -74144,28 +69403,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, depthClipEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( depthClipEnable == rhs.depthClipEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -74191,29 +69462,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationDepthClipStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const &
-                            pipelineRasterizationDepthClipStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT,
-                             seed,
-                             pipelineRasterizationDepthClipStateCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRasterizationLineStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationLineStateCreateInfoEXT;
@@ -74292,30 +69540,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineRasterizationLineStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationLineStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               uint16_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( lineRasterizationMode == rhs.lineRasterizationMode ) &&
-             ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) &&
-             ( lineStipplePattern == rhs.lineStipplePattern );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -74344,31 +69604,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationLineStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const &
-                            pipelineRasterizationLineStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationLineStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationLineStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT,
-                             seed,
-                             pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor );
-    VULKAN_HPP_HASH_COMBINE( uint16_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
@@ -74421,27 +69656,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, provokingVertexMode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -74468,27 +69715,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const &
-                            pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT,
-                             seed,
-                             pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRasterizationStateRasterizationOrderAMD
   {
     using NativeType = VkPipelineRasterizationStateRasterizationOrderAMD;
@@ -74540,27 +69766,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>( this );
     }
 
-    operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RasterizationOrderAMD const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, rasterizationOrder );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default;
 #else
     bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -74586,27 +69824,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationStateRasterizationOrderAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const &
-                            pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateRasterizationOrderAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateRasterizationOrderAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RasterizationOrderAMD,
-                             seed,
-                             pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRasterizationStateStreamCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationStateStreamCreateInfoEXT;
@@ -74666,28 +69883,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, rasterizationStream );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( rasterizationStream == rhs.rasterizationStream );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -74713,28 +69942,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationStateStreamCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const &
-                            pipelineRasterizationStateStreamCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateStreamCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT,
-                             seed,
-                             pipelineRasterizationStateStreamCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRenderingCreateInfoKHR
   {
     using NativeType = VkPipelineRenderingCreateInfoKHR;
@@ -74841,31 +70048,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRenderingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRenderingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRenderingCreateInfoKHR *>( this );
     }
 
-    operator VkPipelineRenderingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRenderingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRenderingCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Format * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::Format const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       viewMask,
+                       colorAttachmentCount,
+                       pColorAttachmentFormats,
+                       depthAttachmentFormat,
+                       stencilAttachmentFormat );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRenderingCreateInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) &&
-             ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
-             ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
-             ( depthAttachmentFormat == rhs.depthAttachmentFormat ) &&
-             ( stencilAttachmentFormat == rhs.stencilAttachmentFormat );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -74893,30 +70118,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRenderingCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR const & pipelineRenderingCreateInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRenderingCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRenderingCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.viewMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.colorAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::Format *, seed, pipelineRenderingCreateInfoKHR.pColorAttachmentFormats );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.depthAttachmentFormat );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.stencilAttachmentFormat );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineRepresentativeFragmentTestStateCreateInfoNV
   {
     using NativeType = VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
@@ -74968,28 +70169,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, representativeFragmentTestEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75014,27 +70224,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const &
-                            pipelineRepresentativeFragmentTestStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
-                             seed,
-                             pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineSampleLocationsStateCreateInfoEXT
   {
     using NativeType = VkPipelineSampleLocationsStateCreateInfoEXT;
@@ -75094,29 +70283,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( sampleLocationsEnable == rhs.sampleLocationsEnable ) &&
-             ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75142,29 +70342,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineSampleLocationsStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const &
-                            pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineSampleLocationsStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineSampleLocationsStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT,
-                             seed,
-                             pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
   {
     using NativeType = VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
@@ -75200,27 +70377,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, requiredSubgroupSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75245,26 +70432,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &
-                            pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.requiredSubgroupSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineTessellationDomainOriginStateCreateInfo
   {
     using NativeType = VkPipelineTessellationDomainOriginStateCreateInfo;
@@ -75315,27 +70482,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>( this );
     }
 
-    operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::TessellationDomainOrigin const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, domainOrigin );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75362,27 +70541,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const &
-                            pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationDomainOriginStateCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationDomainOriginStateCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin,
-                             seed,
-                             pipelineTessellationDomainOriginStateCreateInfo.domainOrigin );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct VertexInputBindingDivisorDescriptionEXT
   {
     using NativeType = VkVertexInputBindingDivisorDescriptionEXT;
@@ -75429,27 +70587,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVertexInputBindingDivisorDescriptionEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputBindingDivisorDescriptionEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT *>( this );
     }
 
-    operator VkVertexInputBindingDivisorDescriptionEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputBindingDivisorDescriptionEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( binding, divisor );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputBindingDivisorDescriptionEXT const & ) const = default;
 #else
     bool operator==( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( binding == rhs.binding ) && ( divisor == rhs.divisor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75467,23 +70635,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>::value,
     "VertexInputBindingDivisorDescriptionEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const &
-                            vertexInputBindingDivisorDescriptionEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.binding );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.divisor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineVertexInputDivisorStateCreateInfoEXT
   {
     using NativeType = VkPipelineVertexInputDivisorStateCreateInfoEXT;
@@ -75566,29 +70717,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineVertexInputDivisorStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineVertexInputDivisorStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineVertexInputDivisorStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineVertexInputDivisorStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) &&
-             ( pVertexBindingDivisors == rhs.pVertexBindingDivisors );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75614,28 +70776,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineVertexInputDivisorStateCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const &
-                            pipelineVertexInputDivisorStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT *,
-                             seed,
-                             pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
@@ -75728,29 +70868,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) &&
-             ( customSampleOrderCount == rhs.customSampleOrderCount ) &&
-             ( pCustomSampleOrders == rhs.pCustomSampleOrders );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75778,32 +70930,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const &
-                            pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV,
-                             seed,
-                             pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV *,
-                             seed,
-                             pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineViewportDepthClipControlCreateInfoEXT
   {
     using NativeType = VkPipelineViewportDepthClipControlCreateInfoEXT;
@@ -75853,27 +70979,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT *>( this );
     }
 
-    operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, negativeOneToOne );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -75898,26 +71034,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportDepthClipControlCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const &
-                            pipelineViewportDepthClipControlCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportDepthClipControlCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineViewportExclusiveScissorStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportExclusiveScissorStateCreateInfoNV;
@@ -75997,28 +71113,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && ( pExclusiveScissors == rhs.pExclusiveScissors );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -76044,28 +71172,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportExclusiveScissorStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const &
-                            pipelineViewportExclusiveScissorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *,
-                             seed,
-                             pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ShadingRatePaletteNV
   {
     using NativeType = VkShadingRatePaletteNV;
@@ -76129,28 +71235,37 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShadingRatePaletteNV *>( this );
     }
 
-    operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkShadingRatePaletteNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShadingRatePaletteNV const & ) const = default;
 #else
     bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) &&
-             ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -76165,24 +71280,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>::value,
                             "ShadingRatePaletteNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shadingRatePaletteNV.shadingRatePaletteEntryCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV *, seed, shadingRatePaletteNV.pShadingRatePaletteEntries );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineViewportShadingRateImageStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportShadingRateImageStateCreateInfoNV;
@@ -76274,29 +71371,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && ( viewportCount == rhs.viewportCount ) &&
-             ( pShadingRatePalettes == rhs.pShadingRatePalettes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -76323,30 +71432,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportShadingRateImageStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const &
-                            pipelineViewportShadingRateImageStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV *,
-                             seed,
-                             pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ViewportSwizzleNV
   {
     using NativeType = VkViewportSwizzleNV;
@@ -76412,27 +71497,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViewportSwizzleNV *>( this );
     }
 
-    operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkViewportSwizzleNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
+               VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
+               VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
+               VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( x, y, z, w );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ViewportSwizzleNV const & ) const = default;
 #else
     bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -76449,24 +71547,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>::value,
                             "ViewportSwizzleNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.x );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.y );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.z );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.w );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineViewportSwizzleStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportSwizzleStateCreateInfoNV;
@@ -76557,28 +71637,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( viewportCount == rhs.viewportCount ) && ( pViewportSwizzles == rhs.pViewportSwizzles );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -76605,31 +71698,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportSwizzleStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const &
-                            pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportSwizzleStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportSwizzleStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV,
-                             seed,
-                             pipelineViewportSwizzleStateCreateInfoNV.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV *,
-                             seed,
-                             pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ViewportWScalingNV
   {
     using NativeType = VkViewportWScalingNV;
@@ -76669,27 +71737,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViewportWScalingNV *>( this );
     }
 
-    operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkViewportWScalingNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<float const &, float const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( xcoeff, ycoeff );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ViewportWScalingNV const & ) const = default;
 #else
     bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -76704,23 +71782,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>::value,
                             "ViewportWScalingNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.xcoeff );
-    VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.ycoeff );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PipelineViewportWScalingStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportWScalingStateCreateInfoNV;
@@ -76811,29 +71872,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>( this );
     }
 
-    operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && ( viewportCount == rhs.viewportCount ) &&
-             ( pViewportWScalings == rhs.pViewportWScalings );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -76860,30 +71933,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportWScalingStateCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const &
-                            pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportWScalingStateCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportWScalingStateCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportWScalingNV *,
-                             seed,
-                             pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_GGP )
   struct PresentFrameTokenGGP
   {
@@ -76926,28 +71975,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentFrameTokenGGP *>( this );
     }
 
-    operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPresentFrameTokenGGP *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, GgpFrameToken const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, frameToken );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentFrameTokenGGP const & ) const = default;
 #  else
     bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -76968,25 +72026,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PresentFrameTokenGGP;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentFrameTokenGGP.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentFrameTokenGGP.pNext );
-    VULKAN_HPP_HASH_COMBINE( GgpFrameToken, seed, presentFrameTokenGGP.frameToken );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_GGP*/
 
   struct PresentIdKHR
@@ -77054,28 +72093,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentIdKHR *>( this );
     }
 
-    operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPresentIdKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint64_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, swapchainCount, pPresentIds );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentIdKHR const & ) const = default;
 #else
     bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
-             ( pPresentIds == rhs.pPresentIds );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -77098,24 +72149,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentIdKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentIdKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentIdKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentIdKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentIdKHR.swapchainCount );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, presentIdKHR.pPresentIds );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PresentInfoKHR
   {
     using NativeType = VkPresentInfoKHR;
@@ -77280,30 +72313,45 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentInfoKHR *>( this );
     }
 
-    operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPresentInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SwapchainKHR * const &,
+               const uint32_t * const &,
+               VULKAN_HPP_NAMESPACE::Result * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentInfoKHR const & ) const = default;
 #else
     bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
-             ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( swapchainCount == rhs.swapchainCount ) &&
-             ( pSwapchains == rhs.pSwapchains ) && ( pImageIndices == rhs.pImageIndices ) &&
-             ( pResults == rhs.pResults );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -77330,28 +72378,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.waitSemaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, presentInfoKHR.pWaitSemaphores );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.swapchainCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SwapchainKHR *, seed, presentInfoKHR.pSwapchains );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, presentInfoKHR.pImageIndices );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Result *, seed, presentInfoKHR.pResults );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RectLayerKHR
   {
     using NativeType = VkRectLayerKHR;
@@ -77406,27 +72432,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRectLayerKHR *>( this );
     }
 
-    operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRectLayerKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Offset2D const &, VULKAN_HPP_NAMESPACE::Extent2D const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( offset, extent, layer );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RectLayerKHR const & ) const = default;
 #else
     bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -77442,23 +72478,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RectLayerKHR>::value,
                             "RectLayerKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RectLayerKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rectLayerKHR.offset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rectLayerKHR.extent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rectLayerKHR.layer );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PresentRegionKHR
   {
     using NativeType = VkPresentRegionKHR;
@@ -77519,27 +72538,37 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentRegionKHR *>( this );
     }
 
-    operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPresentRegionKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::RectLayerKHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( rectangleCount, pRectangles );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentRegionKHR const & ) const = default;
 #else
     bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -77554,22 +72583,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PresentRegionKHR>::value,
                             "PresentRegionKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionKHR.rectangleCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RectLayerKHR *, seed, presentRegionKHR.pRectangles );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PresentRegionsKHR
   {
     using NativeType = VkPresentRegionsKHR;
@@ -77639,28 +72652,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentRegionsKHR *>( this );
     }
 
-    operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPresentRegionsKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PresentRegionKHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, swapchainCount, pRegions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentRegionsKHR const & ) const = default;
 #else
     bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
-             ( pRegions == rhs.pRegions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -77683,24 +72708,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentRegionsKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentRegionsKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentRegionsKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionsKHR.swapchainCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentRegionKHR *, seed, presentRegionsKHR.pRegions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PresentTimeGOOGLE
   {
     using NativeType = VkPresentTimeGOOGLE;
@@ -77742,27 +72749,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentTimeGOOGLE *>( this );
     }
 
-    operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPresentTimeGOOGLE *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( presentID, desiredPresentTime );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentTimeGOOGLE const & ) const = default;
 #else
     bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -77777,22 +72794,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>::value,
                             "PresentTimeGOOGLE is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimeGOOGLE.presentID );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, presentTimeGOOGLE.desiredPresentTime );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PresentTimesInfoGOOGLE
   {
     using NativeType = VkPresentTimesInfoGOOGLE;
@@ -77862,28 +72863,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentTimesInfoGOOGLE *>( this );
     }
 
-    operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPresentTimesInfoGOOGLE *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, swapchainCount, pTimes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default;
 #else
     bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
-             ( pTimes == rhs.pTimes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -77907,25 +72920,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentTimesInfoGOOGLE;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentTimesInfoGOOGLE.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentTimesInfoGOOGLE.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimesInfoGOOGLE.swapchainCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE *, seed, presentTimesInfoGOOGLE.pTimes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct PrivateDataSlotCreateInfoEXT
   {
     using NativeType = VkPrivateDataSlotCreateInfoEXT;
@@ -77969,27 +72963,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPrivateDataSlotCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkPrivateDataSlotCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( this );
     }
 
-    operator VkPrivateDataSlotCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkPrivateDataSlotCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkPrivateDataSlotCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PrivateDataSlotCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78013,25 +73019,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PrivateDataSlotCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & privateDataSlotCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, privateDataSlotCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, privateDataSlotCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT, seed, privateDataSlotCreateInfoEXT.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ProtectedSubmitInfo
   {
     using NativeType = VkProtectedSubmitInfo;
@@ -78074,27 +73061,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkProtectedSubmitInfo *>( this );
     }
 
-    operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkProtectedSubmitInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, protectedSubmit );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ProtectedSubmitInfo const & ) const = default;
 #else
     bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78116,24 +73113,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ProtectedSubmitInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, protectedSubmitInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, protectedSubmitInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, protectedSubmitInfo.protectedSubmit );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueryPoolCreateInfo
   {
     using NativeType = VkQueryPoolCreateInfo;
@@ -78203,29 +73182,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueryPoolCreateInfo *>( this );
     }
 
-    operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueryPoolCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::QueryType const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueryPoolCreateInfo const & ) const = default;
 #else
     bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) &&
-             ( pipelineStatistics == rhs.pipelineStatistics );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78250,28 +73242,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueryPoolCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags, seed, queryPoolCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryType, seed, queryPoolCreateInfo.queryType );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolCreateInfo.queryCount );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, queryPoolCreateInfo.pipelineStatistics );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueryPoolPerformanceCreateInfoKHR
   {
     using NativeType = VkQueryPoolPerformanceCreateInfoKHR;
@@ -78355,28 +73325,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( this );
     }
 
-    operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default;
 #else
     bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
-             ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78402,26 +73385,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueryPoolPerformanceCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const &
-                            queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueryPoolPerformanceQueryCreateInfoINTEL
   {
     using NativeType = VkQueryPoolPerformanceQueryCreateInfoINTEL;
@@ -78473,28 +73436,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL *>( this );
     }
 
-    operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, performanceCountersSampling );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default;
 #else
     bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( performanceCountersSampling == rhs.performanceCountersSampling );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78521,27 +73495,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const &
-                            queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceQueryCreateInfoINTEL.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL,
-                             seed,
-                             queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueueFamilyCheckpointProperties2NV
   {
     using NativeType = VkQueueFamilyCheckpointProperties2NV;
@@ -78574,28 +73527,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>( this );
     }
 
-    operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueueFamilyCheckpointProperties2NV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, checkpointExecutionStageMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default;
 #else
     bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78619,26 +73583,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueueFamilyCheckpointProperties2NV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const &
-                            queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointProperties2NV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointProperties2NV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR,
-                             seed,
-                             queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueueFamilyCheckpointPropertiesNV
   {
     using NativeType = VkQueueFamilyCheckpointPropertiesNV;
@@ -78670,28 +73614,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>( this );
     }
 
-    operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, checkpointExecutionStageMask );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default;
 #else
     bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78715,25 +73670,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueueFamilyCheckpointPropertiesNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const &
-                            queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointPropertiesNV.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointPropertiesNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueueFamilyGlobalPriorityPropertiesEXT
   {
     using NativeType = VkQueueFamilyGlobalPriorityPropertiesEXT;
@@ -78808,28 +73744,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkQueueFamilyGlobalPriorityPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyGlobalPriorityPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT *>( this );
     }
 
-    operator VkQueueFamilyGlobalPriorityPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyGlobalPriorityPropertiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT,
+                                                    VK_MAX_GLOBAL_PRIORITY_SIZE_EXT> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, priorityCount, priorities );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyGlobalPriorityPropertiesEXT const & ) const = default;
 #else
     bool operator==( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) &&
-             ( priorities == rhs.priorities );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78856,29 +73805,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueueFamilyGlobalPriorityPropertiesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT const &
-                            queueFamilyGlobalPriorityPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyGlobalPriorityPropertiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyGlobalPriorityPropertiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyGlobalPriorityPropertiesEXT.priorityCount );
-    for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_EXT; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE(
-        VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, queueFamilyGlobalPriorityPropertiesEXT.priorities[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueueFamilyProperties
   {
     using NativeType = VkQueueFamilyProperties;
@@ -78910,29 +73836,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyProperties *>( this );
     }
 
-    operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueueFamilyProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::QueueFlags const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyProperties const & ) const = default;
 #else
     bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) &&
-             ( timestampValidBits == rhs.timestampValidBits ) &&
-             ( minImageTransferGranularity == rhs.minImageTransferGranularity );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -78949,25 +73886,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,
                             "QueueFamilyProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueueFlags, seed, queueFamilyProperties.queueFlags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.queueCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.timestampValidBits );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, queueFamilyProperties.minImageTransferGranularity );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct QueueFamilyProperties2
   {
     using NativeType = VkQueueFamilyProperties2;
@@ -78996,27 +73914,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyProperties2 *>( this );
     }
 
-    operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkQueueFamilyProperties2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::QueueFamilyProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, queueFamilyProperties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyProperties2 const & ) const = default;
 #else
     bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -79040,25 +73970,112 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using QueueFamilyProperties2KHR = QueueFamilyProperties2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  struct QueueFamilyQueryResultStatusProperties2KHR
+  {
+    using NativeType = VkQueueFamilyQueryResultStatusProperties2KHR;
 
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyProperties2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyProperties2.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::QueueFamilyProperties, seed, queueFamilyProperties2.queueFamilyProperties );
-    return seed;
-  }
-};
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eQueueFamilyQueryResultStatusProperties2KHR;
+
+#  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR
+      QueueFamilyQueryResultStatusProperties2KHR( VULKAN_HPP_NAMESPACE::Bool32 supported_ = {} ) VULKAN_HPP_NOEXCEPT
+      : supported( supported_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR QueueFamilyQueryResultStatusProperties2KHR(
+      QueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    QueueFamilyQueryResultStatusProperties2KHR( VkQueueFamilyQueryResultStatusProperties2KHR const & rhs )
+      VULKAN_HPP_NOEXCEPT
+      : QueueFamilyQueryResultStatusProperties2KHR(
+          *reinterpret_cast<QueueFamilyQueryResultStatusProperties2KHR const *>( &rhs ) )
+    {}
+#  endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    QueueFamilyQueryResultStatusProperties2KHR &
+      operator=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    QueueFamilyQueryResultStatusProperties2KHR &
+      operator=( VkQueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR const *>( &rhs );
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 QueueFamilyQueryResultStatusProperties2KHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 QueueFamilyQueryResultStatusProperties2KHR &
+                            setSupported( VULKAN_HPP_NAMESPACE::Bool32 supported_ ) VULKAN_HPP_NOEXCEPT
+    {
+      supported = supported_;
+      return *this;
+    }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    explicit operator VkQueueFamilyQueryResultStatusProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkQueueFamilyQueryResultStatusProperties2KHR *>( this );
+    }
+
+    explicit operator VkQueueFamilyQueryResultStatusProperties2KHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkQueueFamilyQueryResultStatusProperties2KHR *>( this );
+    }
+
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, supported );
+    }
+
+#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( QueueFamilyQueryResultStatusProperties2KHR const & ) const = default;
+#  else
+    bool operator==( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() == rhs.reflect();
+    }
+
+    bool operator!=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() != rhs.reflect();
+    }
+#  endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType     = StructureType::eQueueFamilyQueryResultStatusProperties2KHR;
+    void *                              pNext     = {};
+    VULKAN_HPP_NAMESPACE::Bool32        supported = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR ) ==
+                              sizeof( VkQueueFamilyQueryResultStatusProperties2KHR ),
+                            "struct and wrapper have different size!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_standard_layout<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR>::value,
+    "struct wrapper is not a standard layout!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR>::value,
+    "QueueFamilyQueryResultStatusProperties2KHR is not nothrow_move_constructible!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eQueueFamilyQueryResultStatusProperties2KHR>
+  {
+    using Type = QueueFamilyQueryResultStatusProperties2KHR;
+  };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RayTracingShaderGroupCreateInfoKHR
   {
     using NativeType = VkRayTracingShaderGroupCreateInfoKHR;
@@ -79152,30 +74169,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR *>( this );
     }
 
-    operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       type,
+                       generalShader,
+                       closestHitShader,
+                       anyHitShader,
+                       intersectionShader,
+                       pShaderGroupCaptureReplayHandle );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default;
 #else
     bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
-             ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) &&
-             ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ) &&
-             ( pShaderGroupCaptureReplayHandle == rhs.pShaderGroupCaptureReplayHandle );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -79205,30 +74243,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingShaderGroupCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const &
-                            rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoKHR.type );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.generalShader );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RayTracingPipelineInterfaceCreateInfoKHR
   {
     using NativeType = VkRayTracingPipelineInterfaceCreateInfoKHR;
@@ -79288,29 +74302,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR *>( this );
     }
 
-    operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default;
 #else
     bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) &&
-             ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -79336,26 +74358,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingPipelineInterfaceCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const &
-                            rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineInterfaceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RayTracingPipelineCreateInfoKHR
   {
     using NativeType = VkRayTracingPipelineCreateInfoKHR;
@@ -79549,32 +74551,63 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( this );
     }
 
-    operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRayTracingPipelineCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR * const &,
+               const VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo * const &,
+               VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+               VULKAN_HPP_NAMESPACE::Pipeline const &,
+               int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       stageCount,
+                       pStages,
+                       groupCount,
+                       pGroups,
+                       maxPipelineRayRecursionDepth,
+                       pLibraryInfo,
+                       pLibraryInterface,
+                       pDynamicState,
+                       layout,
+                       basePipelineHandle,
+                       basePipelineIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default;
 #else
     bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) &&
-             ( pGroups == rhs.pGroups ) && ( maxPipelineRayRecursionDepth == rhs.maxPipelineRayRecursionDepth ) &&
-             ( pLibraryInfo == rhs.pLibraryInfo ) && ( pLibraryInterface == rhs.pLibraryInterface ) &&
-             ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) &&
-             ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -79609,43 +74642,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingPipelineCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.stageCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoKHR.pStages );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.groupCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pGroups );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR *,
-                             seed,
-                             rayTracingPipelineCreateInfoKHR.pLibraryInterface );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *,
-                             seed,
-                             rayTracingPipelineCreateInfoKHR.pDynamicState );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoKHR.layout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RayTracingShaderGroupCreateInfoNV
   {
     using NativeType = VkRayTracingShaderGroupCreateInfoNV;
@@ -79729,29 +74725,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV *>( this );
     }
 
-    operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default;
 #else
     bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
-             ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) &&
-             ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -79780,29 +74790,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingShaderGroupCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const &
-                            rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoNV.type );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.generalShader );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.closestHitShader );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.anyHitShader );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.intersectionShader );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RayTracingPipelineCreateInfoNV
   {
     using NativeType = VkRayTracingPipelineCreateInfoNV;
@@ -79963,30 +74950,57 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( this );
     }
 
-    operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+               VULKAN_HPP_NAMESPACE::Pipeline const &,
+               int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       stageCount,
+                       pStages,
+                       groupCount,
+                       pGroups,
+                       maxRecursionDepth,
+                       layout,
+                       basePipelineHandle,
+                       basePipelineIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default;
 #else
     bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) &&
-             ( pGroups == rhs.pGroups ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( layout == rhs.layout ) &&
-             ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -80018,34 +75032,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingPipelineCreateInfoNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoNV.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.stageCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoNV.pStages );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.groupCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV *, seed, rayTracingPipelineCreateInfoNV.pGroups );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoNV.layout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoNV.basePipelineHandle );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoNV.basePipelineIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RefreshCycleDurationGOOGLE
   {
     using NativeType = VkRefreshCycleDurationGOOGLE;
@@ -80071,27 +75057,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE *>( this );
     }
 
-    operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( refreshDuration );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default;
 #else
     bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( refreshDuration == rhs.refreshDuration );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -80106,22 +75102,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::value,
                             "RefreshCycleDurationGOOGLE is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, refreshCycleDurationGOOGLE.refreshDuration );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassAttachmentBeginInfo
   {
     using NativeType = VkRenderPassAttachmentBeginInfo;
@@ -80194,28 +75174,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassAttachmentBeginInfo *>( this );
     }
 
-    operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassAttachmentBeginInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ImageView * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, attachmentCount, pAttachments );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default;
 #else
     bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) &&
-             ( pAttachments == rhs.pAttachments );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -80241,26 +75233,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassAttachmentBeginInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassAttachmentBeginInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassAttachmentBeginInfo.attachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::ImageView *, seed, renderPassAttachmentBeginInfo.pAttachments );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassBeginInfo
   {
     using NativeType = VkRenderPassBeginInfo;
@@ -80364,29 +75336,43 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassBeginInfo *>( this );
     }
 
-    operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassBeginInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RenderPass const &,
+               VULKAN_HPP_NAMESPACE::Framebuffer const &,
+               VULKAN_HPP_NAMESPACE::Rect2D const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ClearValue * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassBeginInfo const & ) const = default;
 #else
     bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
-             ( framebuffer == rhs.framebuffer ) && ( renderArea == rhs.renderArea ) &&
-             ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -80412,28 +75398,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassBeginInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassBeginInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassBeginInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, renderPassBeginInfo.renderPass );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, renderPassBeginInfo.framebuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderPassBeginInfo.renderArea );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassBeginInfo.clearValueCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ClearValue *, seed, renderPassBeginInfo.pClearValues );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassDescription
   {
     using NativeType = VkSubpassDescription;
@@ -80628,33 +75592,55 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDescription *>( this );
     }
 
-    operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassDescription *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags const &,
+               VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( flags,
+                       pipelineBindPoint,
+                       inputAttachmentCount,
+                       pInputAttachments,
+                       colorAttachmentCount,
+                       pColorAttachments,
+                       pResolveAttachments,
+                       pDepthStencilAttachment,
+                       preserveAttachmentCount,
+                       pPreserveAttachments );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDescription const & ) const = default;
 #else
     bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
-             ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) &&
-             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
-             ( pResolveAttachments == rhs.pResolveAttachments ) &&
-             ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) &&
-             ( preserveAttachmentCount == rhs.preserveAttachmentCount ) &&
-             ( pPreserveAttachments == rhs.pPreserveAttachments );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -80677,35 +75663,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassDescription>::value,
                             "SubpassDescription is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescription>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription.pipelineBindPoint );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.inputAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pInputAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.colorAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pColorAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pResolveAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pDepthStencilAttachment );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.preserveAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription.pPreserveAttachments );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassDependency
   {
     using NativeType = VkSubpassDependency;
@@ -80792,30 +75749,44 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDependency *>( this );
     }
 
-    operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassDependency *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::DependencyFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDependency const & ) const = default;
 #else
     bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) &&
-             ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) &&
-             ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) &&
-             ( dependencyFlags == rhs.dependencyFlags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -80835,27 +75806,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassDependency>::value,
                             "SubpassDependency is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDependency>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.srcSubpass );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.dstSubpass );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.srcStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.dstStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.dstAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency.dependencyFlags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassCreateInfo
   {
     using NativeType = VkRenderPassCreateInfo;
@@ -81002,30 +75952,46 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassCreateInfo *>( this );
     }
 
-    operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RenderPassCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentDescription * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SubpassDescription * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SubpassDependency * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassCreateInfo const & ) const = default;
 #else
     bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
-             ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) &&
-             ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -81053,32 +76019,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.attachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentDescription *, seed, renderPassCreateInfo.pAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.subpassCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassDescription *, seed, renderPassCreateInfo.pSubpasses );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.dependencyCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SubpassDependency *, seed, renderPassCreateInfo.pDependencies );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassDescription2
   {
     using NativeType = VkSubpassDescription2;
@@ -81292,34 +76232,61 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDescription2 *>( this );
     }
 
-    operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassDescription2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags const &,
+               VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       pipelineBindPoint,
+                       viewMask,
+                       inputAttachmentCount,
+                       pInputAttachments,
+                       colorAttachmentCount,
+                       pColorAttachments,
+                       pResolveAttachments,
+                       pDepthStencilAttachment,
+                       preserveAttachmentCount,
+                       pPreserveAttachments );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDescription2 const & ) const = default;
 #else
     bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( viewMask == rhs.viewMask ) &&
-             ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) &&
-             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
-             ( pResolveAttachments == rhs.pResolveAttachments ) &&
-             ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) &&
-             ( preserveAttachmentCount == rhs.preserveAttachmentCount ) &&
-             ( pPreserveAttachments == rhs.pPreserveAttachments );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -81352,38 +76319,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassDescription2KHR = SubpassDescription2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescription2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescription2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescription2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription2.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription2.pipelineBindPoint );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.viewMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.inputAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pInputAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.colorAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pColorAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pResolveAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pDepthStencilAttachment );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.preserveAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription2.pPreserveAttachments );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassDependency2
   {
     using NativeType = VkSubpassDependency2;
@@ -81486,31 +76421,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDependency2 *>( this );
     }
 
-    operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassDependency2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::AccessFlags const &,
+               VULKAN_HPP_NAMESPACE::DependencyFlags const &,
+               int32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       srcSubpass,
+                       dstSubpass,
+                       srcStageMask,
+                       dstStageMask,
+                       srcAccessMask,
+                       dstAccessMask,
+                       dependencyFlags,
+                       viewOffset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDependency2 const & ) const = default;
 #else
     bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubpass == rhs.srcSubpass ) &&
-             ( dstSubpass == rhs.dstSubpass ) && ( srcStageMask == rhs.srcStageMask ) &&
-             ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
-             ( dstAccessMask == rhs.dstAccessMask ) && ( dependencyFlags == rhs.dependencyFlags ) &&
-             ( viewOffset == rhs.viewOffset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -81540,31 +76499,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassDependency2KHR = SubpassDependency2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDependency2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDependency2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDependency2.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.srcSubpass );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.dstSubpass );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.srcStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.dstStageMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.srcAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.dstAccessMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency2.dependencyFlags );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, subpassDependency2.viewOffset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassCreateInfo2
   {
     using NativeType = VkRenderPassCreateInfo2;
@@ -81741,32 +76675,57 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassCreateInfo2 *>( this );
     }
 
-    operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassCreateInfo2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RenderPassCreateFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentDescription2 * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SubpassDescription2 * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SubpassDependency2 * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       attachmentCount,
+                       pAttachments,
+                       subpassCount,
+                       pSubpasses,
+                       dependencyCount,
+                       pDependencies,
+                       correlatedViewMaskCount,
+                       pCorrelatedViewMasks );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassCreateInfo2 const & ) const = default;
 #else
     bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
-             ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) &&
-             ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ) &&
-             ( correlatedViewMaskCount == rhs.correlatedViewMaskCount ) &&
-             ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -81797,35 +76756,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo2.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo2.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo2.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.attachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::AttachmentDescription2 *, seed, renderPassCreateInfo2.pAttachments );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.subpassCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SubpassDescription2 *, seed, renderPassCreateInfo2.pSubpasses );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.dependencyCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SubpassDependency2 *, seed, renderPassCreateInfo2.pDependencies );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.correlatedViewMaskCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassCreateInfo2.pCorrelatedViewMasks );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassFragmentDensityMapCreateInfoEXT
   {
     using NativeType = VkRenderPassFragmentDensityMapCreateInfoEXT;
@@ -81876,28 +76806,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>( this );
     }
 
-    operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::AttachmentReference const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fragmentDensityMapAttachment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default;
 #else
     bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -81922,27 +76863,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassFragmentDensityMapCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const &
-                            renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassFragmentDensityMapCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassFragmentDensityMapCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentReference,
-                             seed,
-                             renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassInputAttachmentAspectCreateInfo
   {
     using NativeType = VkRenderPassInputAttachmentAspectCreateInfo;
@@ -82022,28 +76942,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>( this );
     }
 
-    operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default;
 #else
     bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) &&
-             ( pAspectReferences == rhs.pAspectReferences );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -82070,28 +77002,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const &
-                            renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassInputAttachmentAspectCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassInputAttachmentAspectCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference *,
-                             seed,
-                             renderPassInputAttachmentAspectCreateInfo.pAspectReferences );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassMultiviewCreateInfo
   {
     using NativeType = VkRenderPassMultiviewCreateInfo;
@@ -82225,30 +77135,51 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>( this );
     }
 
-    operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassMultiviewCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               uint32_t const &,
+               const int32_t * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       subpassCount,
+                       pViewMasks,
+                       dependencyCount,
+                       pViewOffsets,
+                       correlationMaskCount,
+                       pCorrelationMasks );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default;
 #else
     bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) &&
-             ( pViewMasks == rhs.pViewMasks ) && ( dependencyCount == rhs.dependencyCount ) &&
-             ( pViewOffsets == rhs.pViewOffsets ) && ( correlationMaskCount == rhs.correlationMaskCount ) &&
-             ( pCorrelationMasks == rhs.pCorrelationMasks );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -82278,29 +77209,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassMultiviewCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassMultiviewCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.subpassCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pViewMasks );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.dependencyCount );
-    VULKAN_HPP_HASH_COMBINE( const int32_t *, seed, renderPassMultiviewCreateInfo.pViewOffsets );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.correlationMaskCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pCorrelationMasks );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassSampleLocationsEXT
   {
     using NativeType = VkSubpassSampleLocationsEXT;
@@ -82344,27 +77252,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassSampleLocationsEXT *>( this );
     }
 
-    operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassSampleLocationsEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( subpassIndex, sampleLocationsInfo );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassSampleLocationsEXT const & ) const = default;
 #else
     bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -82380,24 +77298,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>::value,
                             "SubpassSampleLocationsEXT is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassSampleLocationsEXT.subpassIndex );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, subpassSampleLocationsEXT.sampleLocationsInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassSampleLocationsBeginInfoEXT
   {
     using NativeType = VkRenderPassSampleLocationsBeginInfoEXT;
@@ -82509,31 +77409,47 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>( this );
     }
 
-    operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       attachmentInitialSampleLocationsCount,
+                       pAttachmentInitialSampleLocations,
+                       postSubpassSampleLocationsCount,
+                       pPostSubpassSampleLocations );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default;
 #else
     bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) &&
-             ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) &&
-             ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) &&
-             ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -82560,32 +77476,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassSampleLocationsBeginInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const &
-                            renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassSampleLocationsBeginInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassSampleLocationsBeginInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT *,
-                             seed,
-                             renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT *,
-                             seed,
-                             renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderPassTransformBeginInfoQCOM
   {
     using NativeType = VkRenderPassTransformBeginInfoQCOM;
@@ -82631,27 +77521,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM *>( this );
     }
 
-    operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderPassTransformBeginInfoQCOM *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, transform );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default;
 #else
     bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -82676,26 +77578,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassTransformBeginInfoQCOM;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassTransformBeginInfoQCOM.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, renderPassTransformBeginInfoQCOM.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, renderPassTransformBeginInfoQCOM.transform );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderingAttachmentInfoKHR
   {
     using NativeType = VkRenderingAttachmentInfoKHR;
@@ -82803,16 +77685,44 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderingAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderingAttachmentInfoKHR *>( this );
     }
 
-    operator VkRenderingAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderingAttachmentInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageView const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
+               VULKAN_HPP_NAMESPACE::ImageView const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+               VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+               VULKAN_HPP_NAMESPACE::ClearValue const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       imageView,
+                       imageLayout,
+                       resolveMode,
+                       resolveImageView,
+                       resolveImageLayout,
+                       loadOp,
+                       storeOp,
+                       clearValue );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType       sType              = StructureType::eRenderingAttachmentInfoKHR;
     const void *                              pNext              = {};
@@ -82899,28 +77809,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT *>( this );
     }
 
-    operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageView const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imageView, imageLayout );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default;
 #else
     bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
-             ( imageLayout == rhs.imageLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -82946,28 +77868,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderingFragmentDensityMapAttachmentInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const &
-                            renderingFragmentDensityMapAttachmentInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentDensityMapAttachmentInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderingFragmentShadingRateAttachmentInfoKHR
   {
     using NativeType = VkRenderingFragmentShadingRateAttachmentInfoKHR;
@@ -83036,29 +77936,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>( this );
     }
 
-    operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ImageView const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default;
 #else
     bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
-             ( imageLayout == rhs.imageLayout ) &&
-             ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -83085,31 +77997,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderingFragmentShadingRateAttachmentInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const &
-                            renderingFragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentShadingRateAttachmentInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
-                             seed,
-                             renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct RenderingInfoKHR
   {
     using NativeType = VkRenderingInfoKHR;
@@ -83246,30 +78133,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderingInfoKHR *>( this );
     }
 
-    operator VkRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkRenderingInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::RenderingFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::Rect2D const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &,
+               const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &,
+               const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       renderArea,
+                       layerCount,
+                       viewMask,
+                       colorAttachmentCount,
+                       pColorAttachments,
+                       pDepthAttachment,
+                       pStencilAttachment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderingInfoKHR const & ) const = default;
 #else
     bool operator==( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( renderArea == rhs.renderArea ) && ( layerCount == rhs.layerCount ) && ( viewMask == rhs.viewMask ) &&
-             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
-             ( pDepthAttachment == rhs.pDepthAttachment ) && ( pStencilAttachment == rhs.pStencilAttachment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -83298,33 +78210,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderingInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderingInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfoKHR const & renderingInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderingInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, renderingInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderingInfoKHR.renderArea );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.layerCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.viewMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.colorAttachmentCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pColorAttachments );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pDepthAttachment );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pStencilAttachment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ResolveImageInfo2KHR
   {
     using NativeType = VkResolveImageInfo2KHR;
@@ -83439,30 +78324,44 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkResolveImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkResolveImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkResolveImageInfo2KHR *>( this );
     }
 
-    operator VkResolveImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkResolveImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkResolveImageInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               VULKAN_HPP_NAMESPACE::Image const &,
+               VULKAN_HPP_NAMESPACE::ImageLayout const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ImageResolve2KHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ResolveImageInfo2KHR const & ) const = default;
 #else
     bool operator==( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
-             ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
-             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
-             ( pRegions == rhs.pRegions );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -83489,29 +78388,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ResolveImageInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR const & resolveImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, resolveImageInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, resolveImageInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.srcImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.srcImageLayout );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.dstImage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.dstImageLayout );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, resolveImageInfo2KHR.regionCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageResolve2KHR *, seed, resolveImageInfo2KHR.pRegions );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SamplerBorderColorComponentMappingCreateInfoEXT
   {
     using NativeType = VkSamplerBorderColorComponentMappingCreateInfoEXT;
@@ -83571,28 +78447,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT *>( this );
     }
 
-    operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, components, srgb );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default;
 #else
     bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) &&
-             ( srgb == rhs.srgb );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -83618,27 +78506,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SamplerBorderColorComponentMappingCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const &
-                            samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, samplerBorderColorComponentMappingCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerBorderColorComponentMappingCreateInfoEXT.components );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SamplerCreateInfo
   {
     using NativeType = VkSamplerCreateInfo;
@@ -83813,34 +78680,71 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerCreateInfo *>( this );
     }
 
-    operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSamplerCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SamplerCreateFlags const &,
+               VULKAN_HPP_NAMESPACE::Filter const &,
+               VULKAN_HPP_NAMESPACE::Filter const &,
+               VULKAN_HPP_NAMESPACE::SamplerMipmapMode const &,
+               VULKAN_HPP_NAMESPACE::SamplerAddressMode const &,
+               VULKAN_HPP_NAMESPACE::SamplerAddressMode const &,
+               VULKAN_HPP_NAMESPACE::SamplerAddressMode const &,
+               float const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               float const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::CompareOp const &,
+               float const &,
+               float const &,
+               VULKAN_HPP_NAMESPACE::BorderColor const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       magFilter,
+                       minFilter,
+                       mipmapMode,
+                       addressModeU,
+                       addressModeV,
+                       addressModeW,
+                       mipLodBias,
+                       anisotropyEnable,
+                       maxAnisotropy,
+                       compareEnable,
+                       compareOp,
+                       minLod,
+                       maxLod,
+                       borderColor,
+                       unnormalizedCoordinates );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerCreateInfo const & ) const = default;
 #else
     bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) && ( mipmapMode == rhs.mipmapMode ) &&
-             ( addressModeU == rhs.addressModeU ) && ( addressModeV == rhs.addressModeV ) &&
-             ( addressModeW == rhs.addressModeW ) && ( mipLodBias == rhs.mipLodBias ) &&
-             ( anisotropyEnable == rhs.anisotropyEnable ) && ( maxAnisotropy == rhs.maxAnisotropy ) &&
-             ( compareEnable == rhs.compareEnable ) && ( compareOp == rhs.compareOp ) && ( minLod == rhs.minLod ) &&
-             ( maxLod == rhs.maxLod ) && ( borderColor == rhs.borderColor ) &&
-             ( unnormalizedCoordinates == rhs.unnormalizedCoordinates );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -83877,38 +78781,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SamplerCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerCreateFlags, seed, samplerCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.magFilter );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.minFilter );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerMipmapMode, seed, samplerCreateInfo.mipmapMode );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeU );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeV );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeW );
-    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.mipLodBias );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.anisotropyEnable );
-    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxAnisotropy );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.compareEnable );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, samplerCreateInfo.compareOp );
-    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.minLod );
-    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxLod );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BorderColor, seed, samplerCreateInfo.borderColor );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.unnormalizedCoordinates );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SamplerCustomBorderColorCreateInfoEXT
   {
     using NativeType = VkSamplerCustomBorderColorCreateInfoEXT;
@@ -83966,16 +78838,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>( this );
     }
 
-    operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ClearColorValue const &,
+               VULKAN_HPP_NAMESPACE::Format const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, customBorderColor, format );
+    }
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType   sType             = StructureType::eSamplerCustomBorderColorCreateInfoEXT;
     const void *                          pNext             = {};
@@ -84043,27 +78928,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerReductionModeCreateInfo *>( this );
     }
 
-    operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSamplerReductionModeCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SamplerReductionMode const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, reductionMode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default;
 #else
     bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -84089,25 +78986,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerReductionModeCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerReductionModeCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SamplerReductionMode, seed, samplerReductionModeCreateInfo.reductionMode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SamplerYcbcrConversionCreateInfo
   {
     using NativeType = VkSamplerYcbcrConversionCreateInfo;
@@ -84217,30 +79095,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( this );
     }
 
-    operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+               VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+               VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+               VULKAN_HPP_NAMESPACE::Filter const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       format,
+                       ycbcrModel,
+                       ycbcrRange,
+                       components,
+                       xChromaOffset,
+                       yChromaOffset,
+                       chromaFilter,
+                       forceExplicitReconstruction );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default;
 #else
     bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) &&
-             ( ycbcrModel == rhs.ycbcrModel ) && ( ycbcrRange == rhs.ycbcrRange ) && ( components == rhs.components ) &&
-             ( xChromaOffset == rhs.xChromaOffset ) && ( yChromaOffset == rhs.yChromaOffset ) &&
-             ( chromaFilter == rhs.chromaFilter ) && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -84273,38 +79176,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, samplerYcbcrConversionCreateInfo.format );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, samplerYcbcrConversionCreateInfo.ycbcrModel );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, samplerYcbcrConversionCreateInfo.ycbcrRange );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerYcbcrConversionCreateInfo.components );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.xChromaOffset );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.yChromaOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerYcbcrConversionCreateInfo.chromaFilter );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SamplerYcbcrConversionImageFormatProperties
   {
     using NativeType = VkSamplerYcbcrConversionImageFormatProperties;
@@ -84339,28 +79210,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>( this );
     }
 
-    operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, combinedImageSamplerDescriptorCount );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default;
 #else
     bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -84386,26 +79266,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const &
-                            samplerYcbcrConversionImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionImageFormatProperties.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, samplerYcbcrConversionImageFormatProperties.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      uint32_t, seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SamplerYcbcrConversionInfo
   {
     using NativeType = VkSamplerYcbcrConversionInfo;
@@ -84450,27 +79310,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionInfo *>( this );
     }
 
-    operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSamplerYcbcrConversionInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, conversion );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default;
 #else
     bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -84494,25 +79366,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, seed, samplerYcbcrConversionInfo.conversion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
   struct ScreenSurfaceCreateInfoQNX
   {
@@ -84575,28 +79428,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( this );
     }
 
-    operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkScreenSurfaceCreateInfoQNX *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX const &,
+               struct _screen_context * const &,
+               struct _screen_window * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, context, window );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default;
 #  else
     bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) &&
-             ( window == rhs.window );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -84620,28 +79486,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ScreenSurfaceCreateInfoQNX;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, screenSurfaceCreateInfoQNX.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, screenSurfaceCreateInfoQNX.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX, seed, screenSurfaceCreateInfoQNX.flags );
-    VULKAN_HPP_HASH_COMBINE( struct _screen_context *, seed, screenSurfaceCreateInfoQNX.context );
-    VULKAN_HPP_HASH_COMBINE( struct _screen_window *, seed, screenSurfaceCreateInfoQNX.window );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
   struct SemaphoreCreateInfo
@@ -84687,27 +79531,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreCreateInfo *>( this );
     }
 
-    operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreCreateInfo const & ) const = default;
 #else
     bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -84729,24 +79585,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SemaphoreCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags, seed, semaphoreCreateInfo.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SemaphoreGetFdInfoKHR
   {
     using NativeType = VkSemaphoreGetFdInfoKHR;
@@ -84800,28 +79638,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( this );
     }
 
-    operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreGetFdInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, handleType );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default;
 #else
     bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -84845,26 +79695,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SemaphoreGetFdInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetFdInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetFdInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetFdInfoKHR.semaphore );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetFdInfoKHR.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct SemaphoreGetWin32HandleInfoKHR
   {
@@ -84921,28 +79751,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( this );
     }
 
-    operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, handleType );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -84967,27 +79809,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SemaphoreGetWin32HandleInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetWin32HandleInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetWin32HandleInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetWin32HandleInfoKHR.semaphore );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetWin32HandleInfoKHR.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -85048,28 +79869,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( this );
     }
 
-    operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, handleType );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( handleType == rhs.handleType );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -85094,27 +79927,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SemaphoreGetZirconHandleInfoFUCHSIA;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const &
-                            semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetZirconHandleInfoFUCHSIA.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct SemaphoreSignalInfo
@@ -85167,28 +79979,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreSignalInfo *>( this );
     }
 
-    operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreSignalInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, value );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreSignalInfo const & ) const = default;
 #else
     bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( value == rhs.value );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -85212,25 +80036,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSignalInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSignalInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSignalInfo.semaphore );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSignalInfo.value );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SemaphoreSubmitInfoKHR
   {
     using NativeType = VkSemaphoreSubmitInfoKHR;
@@ -85298,28 +80103,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreSubmitInfoKHR *>( this );
     }
 
-    operator VkSemaphoreSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreSubmitInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Semaphore const &,
+               uint64_t const &,
+               VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreSubmitInfoKHR const & ) const = default;
 #else
     bool operator==( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
-             ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && ( deviceIndex == rhs.deviceIndex );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -85345,27 +80164,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SemaphoreSubmitInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR const & semaphoreSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSubmitInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSubmitInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSubmitInfoKHR.semaphore );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSubmitInfoKHR.value );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, semaphoreSubmitInfoKHR.stageMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreSubmitInfoKHR.deviceIndex );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SemaphoreTypeCreateInfo
   {
     using NativeType = VkSemaphoreTypeCreateInfo;
@@ -85417,28 +80215,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreTypeCreateInfo *>( this );
     }
 
-    operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreTypeCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SemaphoreType const &,
+               uint64_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, semaphoreType, initialValue );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default;
 #else
     bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) &&
-             ( initialValue == rhs.initialValue );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -85463,25 +80273,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreTypeCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreTypeCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreType, seed, semaphoreTypeCreateInfo.semaphoreType );
-    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreTypeCreateInfo.initialValue );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SemaphoreWaitInfo
   {
     using NativeType = VkSemaphoreWaitInfo;
@@ -85592,29 +80383,42 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreWaitInfo *>( this );
     }
 
-    operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSemaphoreWaitInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+               const uint64_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreWaitInfo const & ) const = default;
 #else
     bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( semaphoreCount == rhs.semaphoreCount ) && ( pSemaphores == rhs.pSemaphores ) &&
-             ( pValues == rhs.pValues );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -85640,26 +80444,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreWaitInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreWaitInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags, seed, semaphoreWaitInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreWaitInfo.semaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, semaphoreWaitInfo.pSemaphores );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, semaphoreWaitInfo.pValues );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SetStateFlagsIndirectCommandNV
   {
     using NativeType = VkSetStateFlagsIndirectCommandNV;
@@ -85692,27 +80476,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSetStateFlagsIndirectCommandNV *>( this );
     }
 
-    operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSetStateFlagsIndirectCommandNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( data );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default;
 #else
     bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( data == rhs.data );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -85728,22 +80522,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>::value,
     "SetStateFlagsIndirectCommandNV is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, setStateFlagsIndirectCommandNV.data );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ShaderModuleCreateInfo
   {
     using NativeType = VkShaderModuleCreateInfo;
@@ -85819,28 +80597,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderModuleCreateInfo *>( this );
     }
 
-    operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkShaderModuleCreateInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags const &,
+               size_t const &,
+               const uint32_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, codeSize, pCode );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderModuleCreateInfo const & ) const = default;
 #else
     bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -85865,26 +80656,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ShaderModuleCreateInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleCreateInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleCreateInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags, seed, shaderModuleCreateInfo.flags );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderModuleCreateInfo.codeSize );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, shaderModuleCreateInfo.pCode );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ShaderModuleValidationCacheCreateInfoEXT
   {
     using NativeType = VkShaderModuleValidationCacheCreateInfoEXT;
@@ -85935,27 +80706,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT *>( this );
     }
 
-    operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ValidationCacheEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, validationCache );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -85980,26 +80763,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ShaderModuleValidationCacheCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const &
-                            shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleValidationCacheCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleValidationCacheCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ValidationCacheEXT, seed, shaderModuleValidationCacheCreateInfoEXT.validationCache );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ShaderResourceUsageAMD
   {
     using NativeType = VkShaderResourceUsageAMD;
@@ -86032,30 +80795,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderResourceUsageAMD *>( this );
     }
 
-    operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkShaderResourceUsageAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, size_t const &, size_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderResourceUsageAMD const & ) const = default;
 #else
     bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) &&
-             ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) &&
-             ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) &&
-             ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86074,26 +80845,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>::value,
                             "ShaderResourceUsageAMD is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedVgprs );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedSgprs );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.ldsUsageSizeInBytes );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.scratchMemUsageInBytes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ShaderStatisticsInfoAMD
   {
     using NativeType = VkShaderStatisticsInfoAMD;
@@ -86132,30 +80883,49 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderStatisticsInfoAMD *>( this );
     }
 
-    operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkShaderStatisticsInfoAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+               VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( shaderStageMask,
+                       resourceUsage,
+                       numPhysicalVgprs,
+                       numPhysicalSgprs,
+                       numAvailableVgprs,
+                       numAvailableSgprs,
+                       computeWorkGroupSize );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default;
 #else
     bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) &&
-             ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) &&
-             ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) &&
-             ( computeWorkGroupSize == rhs.computeWorkGroupSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86176,32 +80946,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>::value,
                             "ShaderStatisticsInfoAMD is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, shaderStatisticsInfoAMD.shaderStageMask );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD, seed, shaderStatisticsInfoAMD.resourceUsage );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalVgprs );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalSgprs );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableVgprs );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableSgprs );
-    for ( size_t i = 0; i < 3; ++i )
-    {
-      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] );
-    }
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SharedPresentSurfaceCapabilitiesKHR
   {
     using NativeType = VkSharedPresentSurfaceCapabilitiesKHR;
@@ -86234,28 +80978,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR *>( this );
     }
 
-    operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, sharedPresentSupportedUsageFlags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86279,26 +81033,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SharedPresentSurfaceCapabilitiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const &
-                            sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sharedPresentSurfaceCapabilitiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, sharedPresentSurfaceCapabilitiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags,
-                             seed,
-                             sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseImageFormatProperties
   {
     using NativeType = VkSparseImageFormatProperties;
@@ -86329,27 +81063,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties *>( this );
     }
 
-    operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseImageFormatProperties *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &,
+               VULKAN_HPP_NAMESPACE::Extent3D const &,
+               VULKAN_HPP_NAMESPACE::SparseImageFormatFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( aspectMask, imageGranularity, flags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageFormatProperties const & ) const = default;
 #else
     bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86367,24 +81113,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
     "SparseImageFormatProperties is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, sparseImageFormatProperties.aspectMask );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageFormatProperties.imageGranularity );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseImageFormatFlags, seed, sparseImageFormatProperties.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseImageFormatProperties2
   {
     using NativeType = VkSparseImageFormatProperties2;
@@ -86414,27 +81142,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties2 *>( this );
     }
 
-    operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseImageFormatProperties2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, properties );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageFormatProperties2 const & ) const = default;
 #else
     bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86459,25 +81199,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageFormatProperties2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageFormatProperties2.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageFormatProperties2.properties );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseImageMemoryRequirements
   {
     using NativeType = VkSparseImageMemoryRequirements;
@@ -86513,29 +81234,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements *>( this );
     }
 
-    operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseImageMemoryRequirements *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryRequirements const & ) const = default;
 #else
     bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) &&
-             ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) &&
-             ( imageMipTailStride == rhs.imageMipTailStride );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86555,27 +81289,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
     "SparseImageMemoryRequirements is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageMemoryRequirements.formatProperties );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryRequirements.imageMipTailFirstLod );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailSize );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailStride );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SparseImageMemoryRequirements2
   {
     using NativeType = VkSparseImageMemoryRequirements2;
@@ -86606,27 +81319,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements2 *>( this );
     }
 
-    operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSparseImageMemoryRequirements2 *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryRequirements );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default;
 #else
     bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86651,25 +81376,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageMemoryRequirements2.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageMemoryRequirements2.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, seed, sparseImageMemoryRequirements2.memoryRequirements );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_GGP )
   struct StreamDescriptorSurfaceCreateInfoGGP
   {
@@ -86727,28 +81433,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( this );
     }
 
-    operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP const &,
+               GgpStreamDescriptor const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, streamDescriptor );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & ) const = default;
 #  else
     bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -86772,27 +81490,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = StreamDescriptorSurfaceCreateInfoGGP;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &
-                            streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, streamDescriptorSurfaceCreateInfoGGP.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, streamDescriptorSurfaceCreateInfoGGP.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP, seed, streamDescriptorSurfaceCreateInfoGGP.flags );
-    VULKAN_HPP_HASH_COMBINE( GgpStreamDescriptor, seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_GGP*/
 
   struct StridedDeviceAddressRegionKHR
@@ -86849,27 +81546,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( this );
     }
 
-    operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkStridedDeviceAddressRegionKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( deviceAddress, stride, size );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default;
 #else
     bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -86887,24 +81596,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>::value,
     "StridedDeviceAddressRegionKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, stridedDeviceAddressRegionKHR.deviceAddress );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.stride );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.size );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubmitInfo
   {
     using NativeType = VkSubmitInfo;
@@ -87072,30 +81763,53 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubmitInfo *>( this );
     }
 
-    operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubmitInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+               const VULKAN_HPP_NAMESPACE::PipelineStageFlags * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::CommandBuffer * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Semaphore * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       waitSemaphoreCount,
+                       pWaitSemaphores,
+                       pWaitDstStageMask,
+                       commandBufferCount,
+                       pCommandBuffers,
+                       signalSemaphoreCount,
+                       pSignalSemaphores );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubmitInfo const & ) const = default;
 #else
     bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
-             ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) &&
-             ( commandBufferCount == rhs.commandBufferCount ) && ( pCommandBuffers == rhs.pCommandBuffers ) &&
-             ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && ( pSignalSemaphores == rhs.pSignalSemaphores );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -87123,29 +81837,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SubmitInfo;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubmitInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.waitSemaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pWaitSemaphores );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineStageFlags *, seed, submitInfo.pWaitDstStageMask );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.commandBufferCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CommandBuffer *, seed, submitInfo.pCommandBuffers );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.signalSemaphoreCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pSignalSemaphores );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubmitInfo2KHR
   {
     using NativeType = VkSubmitInfo2KHR;
@@ -87294,33 +81985,53 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubmitInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubmitInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubmitInfo2KHR *>( this );
     }
 
-    operator VkSubmitInfo2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubmitInfo2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubmitInfo2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SubmitFlagsKHR const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       waitSemaphoreInfoCount,
+                       pWaitSemaphoreInfos,
+                       commandBufferInfoCount,
+                       pCommandBufferInfos,
+                       signalSemaphoreInfoCount,
+                       pSignalSemaphoreInfos );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubmitInfo2KHR const & ) const = default;
 #else
     bool operator==( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) &&
-             ( pWaitSemaphoreInfos == rhs.pWaitSemaphoreInfos ) &&
-             ( commandBufferInfoCount == rhs.commandBufferInfoCount ) &&
-             ( pCommandBufferInfos == rhs.pCommandBufferInfos ) &&
-             ( signalSemaphoreInfoCount == rhs.signalSemaphoreInfoCount ) &&
-             ( pSignalSemaphoreInfos == rhs.pSignalSemaphoreInfos );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -87348,32 +82059,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SubmitInfo2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubmitInfo2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2KHR const & submitInfo2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubmitFlagsKHR, seed, submitInfo2KHR.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.waitSemaphoreInfoCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pWaitSemaphoreInfos );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.commandBufferInfoCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR *, seed, submitInfo2KHR.pCommandBufferInfos );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.signalSemaphoreInfoCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pSignalSemaphoreInfos );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassBeginInfo
   {
     using NativeType = VkSubpassBeginInfo;
@@ -87417,27 +82102,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassBeginInfo *>( this );
     }
 
-    operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassBeginInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SubpassContents const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, contents );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassBeginInfo const & ) const = default;
 #else
     bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -87460,23 +82157,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassBeginInfoKHR = SubpassBeginInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassBeginInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassBeginInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassContents, seed, subpassBeginInfo.contents );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassDescriptionDepthStencilResolve
   {
     using NativeType = VkSubpassDescriptionDepthStencilResolve;
@@ -87543,29 +82223,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve *>( this );
     }
 
-    operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassDescriptionDepthStencilResolve *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
+               VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
+               const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default;
 #else
     bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) &&
-             ( stencilResolveMode == rhs.stencilResolveMode ) &&
-             ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -87592,30 +82284,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const &
-                            subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescriptionDepthStencilResolve.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescriptionDepthStencilResolve.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.depthResolveMode );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.stencilResolveMode );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *,
-                             seed,
-                             subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassEndInfo
   {
     using NativeType = VkSubpassEndInfo;
@@ -87649,27 +82317,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassEndInfo *>( this );
     }
 
-    operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassEndInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassEndInfo const & ) const = default;
 #else
     bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -87691,22 +82369,144 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassEndInfoKHR = SubpassEndInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
+  struct SubpassFragmentDensityMapOffsetEndInfoQCOM
+  {
+    using NativeType = VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
 
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM(
+      uint32_t                               fragmentDensityOffsetCount_ = {},
+      const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_    = {} ) VULKAN_HPP_NOEXCEPT
+      : fragmentDensityOffsetCount( fragmentDensityOffsetCount_ )
+      , pFragmentDensityOffsets( pFragmentDensityOffsets_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM(
+      SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    SubpassFragmentDensityMapOffsetEndInfoQCOM( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs )
+      VULKAN_HPP_NOEXCEPT
+      : SubpassFragmentDensityMapOffsetEndInfoQCOM(
+          *reinterpret_cast<SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs ) )
+    {}
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    SubpassFragmentDensityMapOffsetEndInfoQCOM(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const &
+        fragmentDensityOffsets_ )
+      : fragmentDensityOffsetCount( static_cast<uint32_t>( fragmentDensityOffsets_.size() ) )
+      , pFragmentDensityOffsets( fragmentDensityOffsets_.data() )
+    {}
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    SubpassFragmentDensityMapOffsetEndInfoQCOM &
+      operator=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    SubpassFragmentDensityMapOffsetEndInfoQCOM &
+      operator=( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
+                            setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
+                            setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityOffsetCount = fragmentDensityOffsetCount_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
+      setPFragmentDensityOffsets( const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pFragmentDensityOffsets = pFragmentDensityOffsets_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    SubpassFragmentDensityMapOffsetEndInfoQCOM & setFragmentDensityOffsets(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const &
+        fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityOffsetCount = static_cast<uint32_t>( fragmentDensityOffsets_.size() );
+      pFragmentDensityOffsets    = fragmentDensityOffsets_.data();
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    explicit operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
+    }
+
+    explicit operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
+    }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::Offset2D * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( SubpassFragmentDensityMapOffsetEndInfoQCOM const & ) const = default;
+#else
+    bool operator==( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() == rhs.reflect();
+    }
+
+    bool operator!=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return this->reflect() != rhs.reflect();
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType    sType = StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
+    const void *                           pNext = {};
+    uint32_t                               fragmentDensityOffsetCount = {};
+    const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets    = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) ==
+                              sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ),
+                            "struct and wrapper have different size!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
+    "struct wrapper is not a standard layout!" );
+  VULKAN_HPP_STATIC_ASSERT(
+    std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
+    "SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM>
   {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassEndInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassEndInfo.pNext );
-    return seed;
-  }
-};
+    using Type = SubpassFragmentDensityMapOffsetEndInfoQCOM;
+  };
 
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SubpassShadingPipelineCreateInfoHUAWEI
   {
     using NativeType = VkSubpassShadingPipelineCreateInfoHUAWEI;
@@ -87741,28 +82541,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI *>( this );
     }
 
-    operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::RenderPass const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, renderPass, subpass );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default;
 #else
     bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
-             ( subpass == rhs.subpass );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -87788,26 +82600,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SubpassShadingPipelineCreateInfoHUAWEI;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const &
-                            subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassShadingPipelineCreateInfoHUAWEI.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, subpassShadingPipelineCreateInfoHUAWEI.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::RenderPass, seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassShadingPipelineCreateInfoHUAWEI.subpass );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SurfaceCapabilities2EXT
   {
     using NativeType = VkSurfaceCapabilities2EXT;
@@ -87857,34 +82649,61 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2EXT *>( this );
     }
 
-    operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceCapabilities2EXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+               VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+               VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       minImageCount,
+                       maxImageCount,
+                       currentExtent,
+                       minImageExtent,
+                       maxImageExtent,
+                       maxImageArrayLayers,
+                       supportedTransforms,
+                       currentTransform,
+                       supportedCompositeAlpha,
+                       supportedUsageFlags,
+                       supportedSurfaceCounters );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilities2EXT const & ) const = default;
 #else
     bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) &&
-             ( maxImageCount == rhs.maxImageCount ) && ( currentExtent == rhs.currentExtent ) &&
-             ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) &&
-             ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( supportedTransforms == rhs.supportedTransforms ) &&
-             ( currentTransform == rhs.currentTransform ) &&
-             ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) &&
-             ( supportedUsageFlags == rhs.supportedUsageFlags ) &&
-             ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -87918,38 +82737,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceCapabilities2EXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2EXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2EXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.minImageCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.currentExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.minImageExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.maxImageExtent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageArrayLayers );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilities2EXT.supportedTransforms );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilities2EXT.currentTransform );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilities2EXT.supportedCompositeAlpha );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilities2EXT.supportedUsageFlags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, surfaceCapabilities2EXT.supportedSurfaceCounters );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SurfaceCapabilitiesKHR
   {
     using NativeType = VkSurfaceCapabilitiesKHR;
@@ -87994,32 +82781,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilitiesKHR *>( this );
     }
 
-    operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceCapabilitiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+               VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( minImageCount,
+                       maxImageCount,
+                       currentExtent,
+                       minImageExtent,
+                       maxImageExtent,
+                       maxImageArrayLayers,
+                       supportedTransforms,
+                       currentTransform,
+                       supportedCompositeAlpha,
+                       supportedUsageFlags );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) &&
-             ( currentExtent == rhs.currentExtent ) && ( minImageExtent == rhs.minImageExtent ) &&
-             ( maxImageExtent == rhs.maxImageExtent ) && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) &&
-             ( supportedTransforms == rhs.supportedTransforms ) && ( currentTransform == rhs.currentTransform ) &&
-             ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) &&
-             ( supportedUsageFlags == rhs.supportedUsageFlags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -88044,34 +82854,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::value,
                             "SurfaceCapabilitiesKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.minImageCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.currentExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.minImageExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.maxImageExtent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageArrayLayers );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilitiesKHR.supportedTransforms );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilitiesKHR.currentTransform );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilitiesKHR.supportedCompositeAlpha );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilitiesKHR.supportedUsageFlags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SurfaceCapabilities2KHR
   {
     using NativeType = VkSurfaceCapabilities2KHR;
@@ -88100,27 +82882,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2KHR *>( this );
     }
 
-    operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceCapabilities2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, surfaceCapabilities );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilities2KHR const & ) const = default;
 #else
     bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -88143,25 +82937,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceCapabilities2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR, seed, surfaceCapabilities2KHR.surfaceCapabilities );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct SurfaceCapabilitiesFullScreenExclusiveEXT
   {
@@ -88212,28 +82987,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>( this );
     }
 
-    operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fullScreenExclusiveSupported );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default;
 #  else
     bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -88257,27 +83041,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SurfaceCapabilitiesFullScreenExclusiveEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const &
-                            surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SurfaceFormatKHR
@@ -88308,27 +83071,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFormatKHR *>( this );
     }
 
-    operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceFormatKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::Format const &, VULKAN_HPP_NAMESPACE::ColorSpaceKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( format, colorSpace );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFormatKHR const & ) const = default;
 #else
     bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -88343,22 +83116,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value,
                             "SurfaceFormatKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, surfaceFormatKHR.format );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, surfaceFormatKHR.colorSpace );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SurfaceFormat2KHR
   {
     using NativeType = VkSurfaceFormat2KHR;
@@ -88387,27 +83144,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFormat2KHR *>( this );
     }
 
-    operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceFormat2KHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, surfaceFormat );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFormat2KHR const & ) const = default;
 #else
     bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -88429,23 +83197,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceFormat2KHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFormat2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFormat2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, seed, surfaceFormat2KHR.surfaceFormat );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct SurfaceFullScreenExclusiveInfoEXT
   {
@@ -88494,27 +83245,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>( this );
     }
 
-    operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, fullScreenExclusive );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default;
 #  else
     bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -88538,26 +83301,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SurfaceFullScreenExclusiveInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const &
-                            surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFullScreenExclusiveInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT, seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -88608,27 +83351,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT *>( this );
     }
 
-    operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, HMONITOR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, hmonitor );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default;
 #  else
     bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -88652,25 +83405,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SurfaceFullScreenExclusiveWin32InfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const &
-                            surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveWin32InfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( HMONITOR, seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SurfaceProtectedCapabilitiesKHR
@@ -88718,27 +83452,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>( this );
     }
 
-    operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, supportsProtected );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -88762,25 +83506,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceProtectedCapabilitiesKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceProtectedCapabilitiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceProtectedCapabilitiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceProtectedCapabilitiesKHR.supportsProtected );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SwapchainCounterCreateInfoEXT
   {
     using NativeType = VkSwapchainCounterCreateInfoEXT;
@@ -88826,27 +83551,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>( this );
     }
 
-    operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, surfaceCounters );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default;
 #else
     bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -88870,25 +83607,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SwapchainCounterCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCounterCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCounterCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, swapchainCounterCreateInfoEXT.surfaceCounters );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SwapchainCreateInfoKHR
   {
     using NativeType = VkSwapchainCreateInfoKHR;
@@ -89116,34 +83834,71 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSwapchainCreateInfoKHR *>( this );
     }
 
-    operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSwapchainCreateInfoKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::SurfaceKHR const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::ColorSpaceKHR const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+               VULKAN_HPP_NAMESPACE::SharingMode const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+               VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR const &,
+               VULKAN_HPP_NAMESPACE::PresentModeKHR const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::SwapchainKHR const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       surface,
+                       minImageCount,
+                       imageFormat,
+                       imageColorSpace,
+                       imageExtent,
+                       imageArrayLayers,
+                       imageUsage,
+                       imageSharingMode,
+                       queueFamilyIndexCount,
+                       pQueueFamilyIndices,
+                       preTransform,
+                       compositeAlpha,
+                       presentMode,
+                       clipped,
+                       oldSwapchain );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SwapchainCreateInfoKHR const & ) const = default;
 #else
     bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) &&
-             ( minImageCount == rhs.minImageCount ) && ( imageFormat == rhs.imageFormat ) &&
-             ( imageColorSpace == rhs.imageColorSpace ) && ( imageExtent == rhs.imageExtent ) &&
-             ( imageArrayLayers == rhs.imageArrayLayers ) && ( imageUsage == rhs.imageUsage ) &&
-             ( imageSharingMode == rhs.imageSharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
-             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( preTransform == rhs.preTransform ) &&
-             ( compositeAlpha == rhs.compositeAlpha ) && ( presentMode == rhs.presentMode ) &&
-             ( clipped == rhs.clipped ) && ( oldSwapchain == rhs.oldSwapchain );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -89183,41 +83938,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SwapchainCreateInfoKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR, seed, swapchainCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, swapchainCreateInfoKHR.surface );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.minImageCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, swapchainCreateInfoKHR.imageFormat );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, swapchainCreateInfoKHR.imageColorSpace );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, swapchainCreateInfoKHR.imageExtent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.imageArrayLayers );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, swapchainCreateInfoKHR.imageUsage );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, swapchainCreateInfoKHR.imageSharingMode );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.queueFamilyIndexCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, swapchainCreateInfoKHR.pQueueFamilyIndices );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, swapchainCreateInfoKHR.preTransform );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR, seed, swapchainCreateInfoKHR.compositeAlpha );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PresentModeKHR, seed, swapchainCreateInfoKHR.presentMode );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainCreateInfoKHR.clipped );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, swapchainCreateInfoKHR.oldSwapchain );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct SwapchainDisplayNativeHdrCreateInfoAMD
   {
     using NativeType = VkSwapchainDisplayNativeHdrCreateInfoAMD;
@@ -89265,27 +83985,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>( this );
     }
 
-    operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, localDimmingEnable );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default;
 #else
     bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -89310,25 +84040,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SwapchainDisplayNativeHdrCreateInfoAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const &
-                            swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainDisplayNativeHdrCreateInfoAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct TextureLODGatherFormatPropertiesAMD
   {
     using NativeType = VkTextureLODGatherFormatPropertiesAMD;
@@ -89361,28 +84072,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>( this );
     }
 
-    operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default;
 #else
     bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -89406,25 +84126,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = TextureLODGatherFormatPropertiesAMD;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const &
-                            textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, textureLODGatherFormatPropertiesAMD.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, textureLODGatherFormatPropertiesAMD.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct TimelineSemaphoreSubmitInfo
   {
     using NativeType = VkTimelineSemaphoreSubmitInfo;
@@ -89527,31 +84228,47 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTimelineSemaphoreSubmitInfo *>( this );
     }
 
-    operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkTimelineSemaphoreSubmitInfo *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint64_t * const &,
+               uint32_t const &,
+               const uint64_t * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       waitSemaphoreValueCount,
+                       pWaitSemaphoreValues,
+                       signalSemaphoreValueCount,
+                       pSignalSemaphoreValues );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default;
 #else
     bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) &&
-             ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) &&
-             ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) &&
-             ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -89579,27 +84296,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, timelineSemaphoreSubmitInfo.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, timelineSemaphoreSubmitInfo.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct TraceRaysIndirectCommandKHR
   {
     using NativeType = VkTraceRaysIndirectCommandKHR;
@@ -89653,27 +84349,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTraceRaysIndirectCommandKHR *>( this );
     }
 
-    operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkTraceRaysIndirectCommandKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( width, height, depth );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default;
 #else
     bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -89691,24 +84397,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>::value,
     "TraceRaysIndirectCommandKHR is not nothrow_move_constructible!" );
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.width );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.height );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.depth );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ValidationCacheCreateInfoEXT
   {
     using NativeType = VkValidationCacheCreateInfoEXT;
@@ -89789,28 +84477,41 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( this );
     }
 
-    operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkValidationCacheCreateInfoEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT const &,
+               size_t const &,
+               const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -89836,27 +84537,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ValidationCacheCreateInfoEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT>
-{
-  std::size_t operator()(
-    VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationCacheCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT, seed, validationCacheCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( size_t, seed, validationCacheCreateInfoEXT.initialDataSize );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pInitialData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ValidationFeaturesEXT
   {
     using NativeType = VkValidationFeaturesEXT;
@@ -89962,31 +84642,47 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkValidationFeaturesEXT *>( this );
     }
 
-    operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkValidationFeaturesEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       enabledValidationFeatureCount,
+                       pEnabledValidationFeatures,
+                       disabledValidationFeatureCount,
+                       pDisabledValidationFeatures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ValidationFeaturesEXT const & ) const = default;
 #else
     bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) &&
-             ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) &&
-             ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) &&
-             ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -90011,31 +84707,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ValidationFeaturesEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFeaturesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFeaturesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.enabledValidationFeatureCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT *,
-                             seed,
-                             validationFeaturesEXT.pEnabledValidationFeatures );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.disabledValidationFeatureCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT *,
-                             seed,
-                             validationFeaturesEXT.pDisabledValidationFeatures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct ValidationFlagsEXT
   {
     using NativeType = VkValidationFlagsEXT;
@@ -90108,29 +84779,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkValidationFlagsEXT *>( this );
     }
 
-    operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkValidationFlagsEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ValidationCheckEXT * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ValidationFlagsEXT const & ) const = default;
 #else
     bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) &&
-             ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -90153,26 +84835,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ValidationFlagsEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFlagsEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFlagsEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFlagsEXT.disabledValidationCheckCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::ValidationCheckEXT *, seed, validationFlagsEXT.pDisabledValidationChecks );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct VertexInputAttributeDescription2EXT
   {
     using NativeType = VkVertexInputAttributeDescription2EXT;
@@ -90244,28 +84906,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( this );
     }
 
-    operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVertexInputAttributeDescription2EXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, location, binding, format, offset );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default;
 #else
     bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) &&
-             ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -90292,27 +84968,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = VertexInputAttributeDescription2EXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const &
-                            vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputAttributeDescription2EXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputAttributeDescription2EXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.location );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.binding );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription2EXT.format );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.offset );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct VertexInputBindingDescription2EXT
   {
     using NativeType = VkVertexInputBindingDescription2EXT;
@@ -90383,28 +85038,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( this );
     }
 
-    operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVertexInputBindingDescription2EXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::VertexInputRate const &,
+               uint32_t const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, binding, stride, inputRate, divisor );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default;
 #else
     bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) &&
-             ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && ( divisor == rhs.divisor );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -90431,27 +85100,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = VertexInputBindingDescription2EXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const &
-                            vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputBindingDescription2EXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputBindingDescription2EXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.binding );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.stride );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription2EXT.inputRate );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.divisor );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_VI_NN )
   struct ViSurfaceCreateInfoNN
   {
@@ -90503,27 +85151,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViSurfaceCreateInfoNN *>( this );
     }
 
-    operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkViSurfaceCreateInfoNN *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN const &,
+               void * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, window );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default;
 #  else
     bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -90545,26 +85206,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ViSurfaceCreateInfoNN;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, viSurfaceCreateInfoNN.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, viSurfaceCreateInfoNN.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN, seed, viSurfaceCreateInfoNN.flags );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, viSurfaceCreateInfoNN.window );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_VI_NN*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -90637,29 +85278,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoPictureResourceKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoPictureResourceKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoPictureResourceKHR *>( this );
     }
 
-    operator VkVideoPictureResourceKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoPictureResourceKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoPictureResourceKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Offset2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ImageView const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoPictureResourceKHR const & ) const = default;
 #  else
     bool operator==( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) &&
-             ( codedExtent == rhs.codedExtent ) && ( baseArrayLayer == rhs.baseArrayLayer ) &&
-             ( imageViewBinding == rhs.imageViewBinding );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -90684,28 +85338,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoPictureResourceKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const & videoPictureResourceKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoPictureResourceKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoPictureResourceKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoPictureResourceKHR.codedOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoPictureResourceKHR.codedExtent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoPictureResourceKHR.baseArrayLayer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, videoPictureResourceKHR.imageViewBinding );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -90760,28 +85392,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoReferenceSlotKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoReferenceSlotKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoReferenceSlotKHR *>( this );
     }
 
-    operator VkVideoReferenceSlotKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoReferenceSlotKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoReferenceSlotKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               int8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, slotIndex, pPictureResource );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoReferenceSlotKHR const & ) const = default;
 #  else
     bool operator==( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
-             ( pPictureResource == rhs.pPictureResource );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -90803,27 +85447,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoReferenceSlotKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR const & videoReferenceSlotKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoReferenceSlotKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoReferenceSlotKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoReferenceSlotKHR.slotIndex );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR *, seed, videoReferenceSlotKHR.pPictureResource );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -90943,30 +85566,51 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( this );
     }
 
-    operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoBeginCodingInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoCodingQualityPresetFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoSessionKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       codecQualityPreset,
+                       videoSession,
+                       videoSessionParameters,
+                       referenceSlotCount,
+                       pReferenceSlots );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( codecQualityPreset == rhs.codecQualityPreset ) && ( videoSession == rhs.videoSession ) &&
-             ( videoSessionParameters == rhs.videoSessionParameters ) &&
-             ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -90993,33 +85637,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoBeginCodingInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBeginCodingInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBeginCodingInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR, seed, videoBeginCodingInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoCodingQualityPresetFlagsKHR, seed, videoBeginCodingInfoKHR.codecQualityPreset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoBeginCodingInfoKHR.videoSession );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, seed, videoBeginCodingInfoKHR.videoSessionParameters );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBeginCodingInfoKHR.referenceSlotCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoBeginCodingInfoKHR.pReferenceSlots );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91091,28 +85708,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoBindMemoryKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoBindMemoryKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoBindMemoryKHR *>( this );
     }
 
-    operator VkVideoBindMemoryKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoBindMemoryKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoBindMemoryKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoBindMemoryKHR const & ) const = default;
 #  else
     bool operator==( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) &&
-             ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91136,28 +85767,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoBindMemoryKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR const & videoBindMemoryKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBindMemoryKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBindMemoryKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBindMemoryKHR.memoryBindIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, videoBindMemoryKHR.memory );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memoryOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memorySize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91202,33 +85811,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoCapabilitiesKHR *>( this );
     }
 
-    operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoCapabilitiesKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint32_t const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       capabilityFlags,
+                       minBitstreamBufferOffsetAlignment,
+                       minBitstreamBufferSizeAlignment,
+                       videoPictureExtentGranularity,
+                       minExtent,
+                       maxExtent,
+                       maxReferencePicturesSlotsCount,
+                       maxReferencePicturesActiveCount );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoCapabilitiesKHR const & ) const = default;
 #  else
     bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilityFlags == rhs.capabilityFlags ) &&
-             ( minBitstreamBufferOffsetAlignment == rhs.minBitstreamBufferOffsetAlignment ) &&
-             ( minBitstreamBufferSizeAlignment == rhs.minBitstreamBufferSizeAlignment ) &&
-             ( videoPictureExtentGranularity == rhs.videoPictureExtentGranularity ) && ( minExtent == rhs.minExtent ) &&
-             ( maxExtent == rhs.maxExtent ) &&
-             ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) &&
-             ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91256,35 +85887,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoCapabilitiesKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCapabilitiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, videoCapabilitiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR, seed, videoCapabilitiesKHR.capabilityFlags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.videoPictureExtentGranularity );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.minExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.maxExtent );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesSlotsCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesActiveCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91332,27 +85934,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoCodingControlInfoKHR *>( this );
     }
 
-    operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoCodingControlInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoCodingControlInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91374,25 +85988,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoCodingControlInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCodingControlInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoCodingControlInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR, seed, videoCodingControlInfoKHR.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91430,29 +86025,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkVideoDecodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT *>( this );
     }
 
-    operator VkVideoDecodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Offset2D const &,
+               VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxLevel, fieldOffsetGranularity, stdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) &&
-             ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ) &&
-             ( stdExtensionVersion == rhs.stdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91477,29 +86084,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264CapabilitiesEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT const & videoDecodeH264CapabilitiesEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264CapabilitiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH264CapabilitiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264CapabilitiesEXT.maxLevel );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeH264CapabilitiesEXT.fieldOffsetGranularity );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH264CapabilitiesEXT.stdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91548,27 +86132,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const StdVideoDecodeH264ReferenceInfo * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pStdReferenceInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91591,26 +86187,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264DpbSlotInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT const & videoDecodeH264DpbSlotInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264DpbSlotInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264DpbSlotInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoDecodeH264ReferenceInfo *, seed, videoDecodeH264DpbSlotInfoEXT.pStdReferenceInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91656,27 +86232,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH264MvcEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264MvcEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264MvcEXT *>( this );
     }
 
-    operator VkVideoDecodeH264MvcEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264MvcEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264MvcEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const StdVideoDecodeH264Mvc * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pStdMvc );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264MvcEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdMvc == rhs.pStdMvc );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91697,25 +86283,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264MvcEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT const & videoDecodeH264MvcEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264MvcEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264MvcEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( const StdVideoDecodeH264Mvc *, seed, videoDecodeH264MvcEXT.pStdMvc );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91800,28 +86367,41 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH264PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264PictureInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const StdVideoDecodeH264PictureInfo * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264PictureInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) &&
-             ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91846,28 +86426,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264PictureInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT const & videoDecodeH264PictureInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264PictureInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264PictureInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoDecodeH264PictureInfo *, seed, videoDecodeH264PictureInfoEXT.pStdPictureInfo );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264PictureInfoEXT.slicesCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH264PictureInfoEXT.pSlicesDataOffsets );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -91924,29 +86482,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264ProfileEXT *>( this );
     }
 
-    operator VkVideoDecodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264ProfileEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               StdVideoH264ProfileIdc const &,
+               VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stdProfileIdc, pictureLayout );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) &&
-             ( pictureLayout == rhs.pictureLayout );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -91969,27 +86538,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264ProfileEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT const & videoDecodeH264ProfileEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264ProfileEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264ProfileEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoDecodeH264ProfileEXT.stdProfileIdc );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT, seed, videoDecodeH264ProfileEXT.pictureLayout );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92049,28 +86597,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoDecodeH264CreateFlagsEXT const &,
+               const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pStdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -92094,29 +86654,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264SessionCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionCreateInfoEXT const &
-                            videoDecodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoDecodeH264CreateFlagsEXT, seed, videoDecodeH264SessionCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
-                             seed,
-                             videoDecodeH264SessionCreateInfoEXT.pStdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92230,28 +86767,42 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const StdVideoH264SequenceParameterSet * const &,
+               uint32_t const &,
+               const StdVideoH264PictureParameterSet * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
-             ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -92278,31 +86829,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264SessionParametersAddInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT const &
-                            videoDecodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersAddInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersAddInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.spsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH264SequenceParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pSpsStd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.ppsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH264PictureParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pPpsStd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92375,28 +86901,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
-             ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -92422,30 +86961,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264SessionParametersCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT const &
-                            videoDecodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxSpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxPpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT *,
-                             seed,
-                             videoDecodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92480,28 +86995,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkVideoDecodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT *>( this );
     }
 
-    operator VkVideoDecodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxLevel, stdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) &&
-             ( stdExtensionVersion == rhs.stdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -92525,27 +87052,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265CapabilitiesEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT const & videoDecodeH265CapabilitiesEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265CapabilitiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH265CapabilitiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265CapabilitiesEXT.maxLevel );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH265CapabilitiesEXT.stdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92594,27 +87100,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const StdVideoDecodeH265ReferenceInfo * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pStdReferenceInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -92637,26 +87155,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265DpbSlotInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT const & videoDecodeH265DpbSlotInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265DpbSlotInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265DpbSlotInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoDecodeH265ReferenceInfo *, seed, videoDecodeH265DpbSlotInfoEXT.pStdReferenceInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92741,28 +87239,41 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH265PictureInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               StdVideoDecodeH265PictureInfo * const &,
+               uint32_t const &,
+               const uint32_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265PictureInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) &&
-             ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -92787,27 +87298,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265PictureInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT const & videoDecodeH265PictureInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265PictureInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265PictureInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( StdVideoDecodeH265PictureInfo *, seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265PictureInfoEXT.slicesCount );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH265PictureInfoEXT.pSlicesDataOffsets );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92854,28 +87344,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH265ProfileEXT *>( this );
     }
 
-    operator VkVideoDecodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH265ProfileEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stdProfileIdc );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -92897,25 +87396,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265ProfileEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT const & videoDecodeH265ProfileEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265ProfileEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265ProfileEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoDecodeH265ProfileEXT.stdProfileIdc );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -92975,28 +87455,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoDecodeH265CreateFlagsEXT const &,
+               const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pStdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -93020,29 +87512,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265SessionCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionCreateInfoEXT const &
-                            videoDecodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoDecodeH265CreateFlagsEXT, seed, videoDecodeH265SessionCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
-                             seed,
-                             videoDecodeH265SessionCreateInfoEXT.pStdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -93156,28 +87625,42 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const StdVideoH265SequenceParameterSet * const &,
+               uint32_t const &,
+               const StdVideoH265PictureParameterSet * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
-             ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -93204,31 +87687,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265SessionParametersAddInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT const &
-                            videoDecodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersAddInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersAddInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.spsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH265SequenceParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pSpsStd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.ppsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH265PictureParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pPpsStd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -93301,28 +87759,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT *>( this );
     }
 
-    operator VkVideoDecodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
-             ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -93348,30 +87819,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265SessionParametersCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT const &
-                            videoDecodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxSpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxPpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT *,
-                             seed,
-                             videoDecodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -93535,32 +87982,59 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoDecodeInfoKHR *>( this );
     }
 
-    operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoDecodeInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::Offset2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const &,
+               const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       codedOffset,
+                       codedExtent,
+                       srcBuffer,
+                       srcBufferOffset,
+                       srcBufferRange,
+                       dstPictureResource,
+                       pSetupReferenceSlot,
+                       referenceSlotCount,
+                       pReferenceSlots );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) &&
-             ( srcBuffer == rhs.srcBuffer ) && ( srcBufferOffset == rhs.srcBufferOffset ) &&
-             ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) &&
-             ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) &&
-             ( pReferenceSlots == rhs.pReferenceSlots );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -93590,37 +88064,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR, seed, videoDecodeInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeInfoKHR.codedOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoDecodeInfoKHR.codedExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoDecodeInfoKHR.srcBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferRange );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoDecodeInfoKHR.dstPictureResource );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pSetupReferenceSlot );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeInfoKHR.referenceSlotCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pReferenceSlots );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -93759,33 +88202,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT *>( this );
     }
 
-    operator VkVideoEncodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint8_t const &,
+               uint8_t const &,
+               uint8_t const &,
+               uint8_t const &,
+               VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       inputModeFlags,
+                       outputModeFlags,
+                       minPictureSizeInMbs,
+                       maxPictureSizeInMbs,
+                       inputImageDataAlignment,
+                       maxNumL0ReferenceForP,
+                       maxNumL0ReferenceForB,
+                       maxNumL1Reference,
+                       qualityLevelCount,
+                       stdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) &&
-             ( minPictureSizeInMbs == rhs.minPictureSizeInMbs ) && ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) &&
-             ( inputImageDataAlignment == rhs.inputImageDataAlignment ) &&
-             ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) &&
-             ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) &&
-             ( qualityLevelCount == rhs.qualityLevelCount ) && ( stdExtensionVersion == rhs.stdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -93818,40 +88289,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264CapabilitiesEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT const & videoEncodeH264CapabilitiesEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264CapabilitiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264CapabilitiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.inputModeFlags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.outputModeFlags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.minPictureSizeInMbs );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.maxPictureSizeInMbs );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.inputImageDataAlignment );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForP );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForB );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL1Reference );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.qualityLevelCount );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH264CapabilitiesEXT.stdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -93908,28 +88345,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               int8_t const &,
+               const StdVideoEncodeH264PictureInfo * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, slotIndex, pStdPictureInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
-             ( pStdPictureInfo == rhs.pStdPictureInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -93953,27 +88402,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264DpbSlotInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT const & videoEncodeH264DpbSlotInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264DpbSlotInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264DpbSlotInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH264DpbSlotInfoEXT.slotIndex );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoEncodeH264PictureInfo *, seed, videoEncodeH264DpbSlotInfoEXT.pStdPictureInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -94074,29 +88502,42 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT *>( this );
     }
 
-    operator VkVideoEncodeH264EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint8_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               const uint8_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, spsId, emitSpsEnable, ppsIdEntryCount, ppsIdEntries );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264EmitPictureParametersEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsId == rhs.spsId ) &&
-             ( emitSpsEnable == rhs.emitSpsEnable ) && ( ppsIdEntryCount == rhs.ppsIdEntryCount ) &&
-             ( ppsIdEntries == rhs.ppsIdEntries );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -94123,29 +88564,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264EmitPictureParametersEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT const &
-                            videoEncodeH264EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264EmitPictureParametersEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264EmitPictureParametersEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264EmitPictureParametersEXT.spsId );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264EmitPictureParametersEXT.emitSpsEnable );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntryCount );
-    VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntries );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -94198,27 +88616,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264FrameSizeEXT *>( this );
     }
 
-    operator VkVideoEncodeH264FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264FrameSizeEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( frameISize, framePSize, frameBSize );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264FrameSizeEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -94235,25 +88663,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT(
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>::value,
     "VideoEncodeH264FrameSizeEXT is not nothrow_move_constructible!" );
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const & videoEncodeH264FrameSizeEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameISize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.framePSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameBSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -94384,31 +88793,51 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264NaluSliceEXT *>( this );
     }
 
-    operator VkVideoEncodeH264NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264NaluSliceEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const StdVideoEncodeH264SliceHeader * const &,
+               uint32_t const &,
+               uint8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &,
+               uint8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       pSliceHeaderStd,
+                       mbCount,
+                       refFinalList0EntryCount,
+                       pRefFinalList0Entries,
+                       refFinalList1EntryCount,
+                       pRefFinalList1Entries );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264NaluSliceEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ) &&
-             ( mbCount == rhs.mbCount ) && ( refFinalList0EntryCount == rhs.refFinalList0EntryCount ) &&
-             ( pRefFinalList0Entries == rhs.pRefFinalList0Entries ) &&
-             ( refFinalList1EntryCount == rhs.refFinalList1EntryCount ) &&
-             ( pRefFinalList1Entries == rhs.pRefFinalList1Entries );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -94436,34 +88865,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264NaluSliceEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT const & videoEncodeH264NaluSliceEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264NaluSliceEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264NaluSliceEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH264SliceHeader *, seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264NaluSliceEXT.mbCount );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList0EntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
-                             seed,
-                             videoEncodeH264NaluSliceEXT.pRefFinalList0Entries );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList1EntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
-                             seed,
-                             videoEncodeH264NaluSliceEXT.pRefFinalList1Entries );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -94510,28 +88911,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264ProfileEXT *>( this );
     }
 
-    operator VkVideoEncodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264ProfileEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH264ProfileIdc const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stdProfileIdc );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -94553,25 +88963,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264ProfileEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT const & videoEncodeH264ProfileEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264ProfileEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264ProfileEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoEncodeH264ProfileEXT.stdProfileIdc );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -94622,27 +89013,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264QpEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264QpEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264QpEXT *>( this );
     }
 
-    operator VkVideoEncodeH264QpEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264QpEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264QpEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<int32_t const &, int32_t const &, int32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( qpI, qpP, qpB );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264QpEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -94657,25 +89058,6 @@ namespace VULKAN_HPP_NAMESPACE
                             "struct wrapper is not a standard layout!" );
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>::value,
                             "VideoEncodeH264QpEXT is not nothrow_move_constructible!" );
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & videoEncodeH264QpEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpI );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpP );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpB );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -94693,11 +89075,13 @@ namespace VULKAN_HPP_NAMESPACE
       uint32_t                                                             idrPeriod_              = {},
       uint32_t                                                             consecutiveBFrameCount_ = {},
       VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure_ =
-        VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown ) VULKAN_HPP_NOEXCEPT
+        VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown,
+      uint8_t temporalLayerCount_ = {} ) VULKAN_HPP_NOEXCEPT
       : gopFrameCount( gopFrameCount_ )
       , idrPeriod( idrPeriod_ )
       , consecutiveBFrameCount( consecutiveBFrameCount_ )
       , rateControlStructure( rateControlStructure_ )
+      , temporalLayerCount( temporalLayerCount_ )
     {}
 
     VULKAN_HPP_CONSTEXPR
@@ -94750,31 +89134,53 @@ namespace VULKAN_HPP_NAMESPACE
       rateControlStructure = rateControlStructure_;
       return *this;
     }
+
+    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT &
+                            setTemporalLayerCount( uint8_t temporalLayerCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      temporalLayerCount = temporalLayerCount_;
+      return *this;
+    }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264RateControlInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH264RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT const &,
+               uint8_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, temporalLayerCount );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264RateControlInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) &&
-             ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) &&
-             ( rateControlStructure == rhs.rateControlStructure );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -94786,6 +89192,7 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t                            consecutiveBFrameCount = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure =
       VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown;
+    uint8_t temporalLayerCount = {};
   };
   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT ) ==
                               sizeof( VkVideoEncodeH264RateControlInfoEXT ),
@@ -94801,30 +89208,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264RateControlInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const &
-                            videoEncodeH264RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.gopFrameCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.idrPeriod );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT,
-                             seed,
-                             videoEncodeH264RateControlInfoEXT.rateControlStructure );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -94948,31 +89331,57 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH264RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint8_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       temporalLayerId,
+                       useInitialRcQp,
+                       initialRcQp,
+                       useMinQp,
+                       minQp,
+                       useMaxQp,
+                       maxQp,
+                       useMaxFrameSize,
+                       maxFrameSize );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264RateControlLayerInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalLayerId == rhs.temporalLayerId ) &&
-             ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) &&
-             ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
-             ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) &&
-             ( maxFrameSize == rhs.maxFrameSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -95004,39 +89413,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264RateControlLayerInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT const &
-                            videoEncodeH264RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlLayerInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlLayerInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264RateControlLayerInfoEXT.temporalLayerId );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useInitialRcQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.initialRcQp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.minQp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxFrameSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxFrameSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -95105,28 +89481,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH264CreateFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, maxPictureSizeInMbs, pStdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -95151,31 +89540,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264SessionCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT const &
-                            videoEncodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH264CreateFlagsEXT, seed, videoEncodeH264SessionCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264SessionCreateInfoEXT.maxPictureSizeInMbs );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
-                             seed,
-                             videoEncodeH264SessionCreateInfoEXT.pStdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -95289,28 +89653,42 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const StdVideoH264SequenceParameterSet * const &,
+               uint32_t const &,
+               const StdVideoH264PictureParameterSet * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
-             ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -95337,31 +89715,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264SessionParametersAddInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT const &
-                            videoEncodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersAddInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersAddInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.spsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH264SequenceParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pSpsStd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.ppsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH264PictureParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pPpsStd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -95434,28 +89787,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
-             ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -95481,30 +89847,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264SessionParametersCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT const &
-                            videoEncodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxSpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxPpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT *,
-                             seed,
-                             videoEncodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -95659,33 +90001,53 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &,
+               uint8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT * const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       refDefaultFinalList0EntryCount,
+                       pRefDefaultFinalList0Entries,
+                       refDefaultFinalList1EntryCount,
+                       pRefDefaultFinalList1Entries,
+                       naluSliceEntryCount,
+                       pNaluSliceEntries,
+                       pCurrentPictureInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( refDefaultFinalList0EntryCount == rhs.refDefaultFinalList0EntryCount ) &&
-             ( pRefDefaultFinalList0Entries == rhs.pRefDefaultFinalList0Entries ) &&
-             ( refDefaultFinalList1EntryCount == rhs.refDefaultFinalList1EntryCount ) &&
-             ( pRefDefaultFinalList1Entries == rhs.pRefDefaultFinalList1Entries ) &&
-             ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) &&
-             ( pCurrentPictureInfo == rhs.pCurrentPictureInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -95714,39 +90076,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264VclFrameInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const & videoEncodeH264VclFrameInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264VclFrameInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264VclFrameInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList0EntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
-                             seed,
-                             videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList0Entries );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList1EntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
-                             seed,
-                             videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList1Entries );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT *,
-                             seed,
-                             videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
-                             seed,
-                             videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -95885,33 +90214,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT *>( this );
     }
 
-    operator VkVideoEncodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               uint8_t const &,
+               uint8_t const &,
+               uint8_t const &,
+               uint8_t const &,
+               uint8_t const &,
+               VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       inputModeFlags,
+                       outputModeFlags,
+                       ctbSizes,
+                       inputImageDataAlignment,
+                       maxNumL0ReferenceForP,
+                       maxNumL0ReferenceForB,
+                       maxNumL1Reference,
+                       maxNumSubLayers,
+                       qualityLevelCount,
+                       stdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) &&
-             ( ctbSizes == rhs.ctbSizes ) && ( inputImageDataAlignment == rhs.inputImageDataAlignment ) &&
-             ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) &&
-             ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) &&
-             ( maxNumSubLayers == rhs.maxNumSubLayers ) && ( qualityLevelCount == rhs.qualityLevelCount ) &&
-             ( stdExtensionVersion == rhs.stdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -95944,41 +90301,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265CapabilitiesEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT const & videoEncodeH265CapabilitiesEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265CapabilitiesEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265CapabilitiesEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.inputModeFlags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.outputModeFlags );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.ctbSizes );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH265CapabilitiesEXT.inputImageDataAlignment );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForP );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForB );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL1Reference );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumSubLayers );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.qualityLevelCount );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH265CapabilitiesEXT.stdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96034,28 +90356,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               int8_t const &,
+               const StdVideoEncodeH265ReferenceInfo * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, slotIndex, pStdReferenceInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
-             ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -96079,27 +90413,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265DpbSlotInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT const & videoEncodeH265DpbSlotInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265DpbSlotInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265DpbSlotInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH265DpbSlotInfoEXT.slotIndex );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoEncodeH265ReferenceInfo *, seed, videoEncodeH265DpbSlotInfoEXT.pStdReferenceInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96221,29 +90534,44 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT *>( this );
     }
 
-    operator VkVideoEncodeH265EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint8_t const &,
+               uint8_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               uint32_t const &,
+               const uint8_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, vpsId, spsId, emitVpsEnable, emitSpsEnable, ppsIdEntryCount, ppsIdEntries );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265EmitPictureParametersEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsId == rhs.vpsId ) && ( spsId == rhs.spsId ) &&
-             ( emitVpsEnable == rhs.emitVpsEnable ) && ( emitSpsEnable == rhs.emitSpsEnable ) &&
-             ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && ( ppsIdEntries == rhs.ppsIdEntries );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -96272,32 +90600,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265EmitPictureParametersEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT const &
-                            videoEncodeH265EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265EmitPictureParametersEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265EmitPictureParametersEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.vpsId );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.spsId );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitVpsEnable );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitSpsEnable );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntryCount );
-    VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntries );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96350,27 +90652,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265FrameSizeEXT *>( this );
     }
 
-    operator VkVideoEncodeH265FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265FrameSizeEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( frameISize, framePSize, frameBSize );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265FrameSizeEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -96387,25 +90699,6 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT(
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>::value,
     "VideoEncodeH265FrameSizeEXT is not nothrow_move_constructible!" );
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & videoEncodeH265FrameSizeEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameISize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.framePSize );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameBSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96527,32 +90820,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265ReferenceListsEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265ReferenceListsEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265ReferenceListsEXT *>( this );
     }
 
-    operator VkVideoEncodeH265ReferenceListsEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265ReferenceListsEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265ReferenceListsEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT * const &,
+               uint8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT * const &,
+               const StdVideoEncodeH265ReferenceModifications * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       referenceList0EntryCount,
+                       pReferenceList0Entries,
+                       referenceList1EntryCount,
+                       pReferenceList1Entries,
+                       pReferenceModifications );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265ReferenceListsEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( referenceList0EntryCount == rhs.referenceList0EntryCount ) &&
-             ( pReferenceList0Entries == rhs.pReferenceList0Entries ) &&
-             ( referenceList1EntryCount == rhs.referenceList1EntryCount ) &&
-             ( pReferenceList1Entries == rhs.pReferenceList1Entries ) &&
-             ( pReferenceModifications == rhs.pReferenceModifications );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -96579,36 +90889,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265ReferenceListsEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT const & videoEncodeH265ReferenceListsEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ReferenceListsEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ReferenceListsEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList0EntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *,
-                             seed,
-                             videoEncodeH265ReferenceListsEXT.pReferenceList0Entries );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList1EntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *,
-                             seed,
-                             videoEncodeH265ReferenceListsEXT.pReferenceList1Entries );
-    VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265ReferenceModifications *,
-                             seed,
-                             videoEncodeH265ReferenceListsEXT.pReferenceModifications );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96673,28 +90953,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265NaluSliceEXT *>( this );
     }
 
-    operator VkVideoEncodeH265NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265NaluSliceEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
+               const StdVideoEncodeH265SliceHeader * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceHeaderStd );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265NaluSliceEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) &&
-             ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -96719,29 +91012,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265NaluSliceEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT const & videoEncodeH265NaluSliceEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265NaluSliceEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265NaluSliceEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265NaluSliceEXT.ctbCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *,
-                             seed,
-                             videoEncodeH265NaluSliceEXT.pReferenceFinalLists );
-    VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265SliceHeader *, seed, videoEncodeH265NaluSliceEXT.pSliceHeaderStd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96788,28 +91058,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265ProfileEXT *>( this );
     }
 
-    operator VkVideoEncodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265ProfileEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, stdProfileIdc );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -96831,25 +91110,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265ProfileEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT const & videoEncodeH265ProfileEXT ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ProfileEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ProfileEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoEncodeH265ProfileEXT.stdProfileIdc );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96900,27 +91160,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265QpEXT *>( this );
     }
 
-    operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265QpEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<int32_t const &, int32_t const &, int32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( qpI, qpP, qpB );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265QpEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -96935,25 +91205,6 @@ namespace VULKAN_HPP_NAMESPACE
                             "struct wrapper is not a standard layout!" );
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>::value,
                             "VideoEncodeH265QpEXT is not nothrow_move_constructible!" );
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & videoEncodeH265QpEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpI );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpP );
-    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpB );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -96971,11 +91222,13 @@ namespace VULKAN_HPP_NAMESPACE
       uint32_t                                                             idrPeriod_              = {},
       uint32_t                                                             consecutiveBFrameCount_ = {},
       VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure_ =
-        VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown ) VULKAN_HPP_NOEXCEPT
+        VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown,
+      uint8_t subLayerCount_ = {} ) VULKAN_HPP_NOEXCEPT
       : gopFrameCount( gopFrameCount_ )
       , idrPeriod( idrPeriod_ )
       , consecutiveBFrameCount( consecutiveBFrameCount_ )
       , rateControlStructure( rateControlStructure_ )
+      , subLayerCount( subLayerCount_ )
     {}
 
     VULKAN_HPP_CONSTEXPR
@@ -97028,31 +91281,53 @@ namespace VULKAN_HPP_NAMESPACE
       rateControlStructure = rateControlStructure_;
       return *this;
     }
+
+    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT &
+                            setSubLayerCount( uint8_t subLayerCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      subLayerCount = subLayerCount_;
+      return *this;
+    }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT const &,
+               uint8_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, subLayerCount );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) &&
-             ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) &&
-             ( rateControlStructure == rhs.rateControlStructure );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -97064,6 +91339,7 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t                            consecutiveBFrameCount = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure =
       VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown;
+    uint8_t subLayerCount = {};
   };
   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT ) ==
                               sizeof( VkVideoEncodeH265RateControlInfoEXT ),
@@ -97079,30 +91355,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265RateControlInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const &
-                            videoEncodeH265RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.gopFrameCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.idrPeriod );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT,
-                             seed,
-                             videoEncodeH265RateControlInfoEXT.rateControlStructure );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -97226,31 +91478,57 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint8_t const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       temporalId,
+                       useInitialRcQp,
+                       initialRcQp,
+                       useMinQp,
+                       minQp,
+                       useMaxQp,
+                       maxQp,
+                       useMaxFrameSize,
+                       maxFrameSize );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalId == rhs.temporalId ) &&
-             ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) &&
-             ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
-             ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) &&
-             ( maxFrameSize == rhs.maxFrameSize );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -97282,39 +91560,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265RateControlLayerInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const &
-                            videoEncodeH265RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlLayerInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlLayerInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265RateControlLayerInfoEXT.temporalId );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useInitialRcQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.initialRcQp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.minQp );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxQp );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxFrameSize );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxFrameSize );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -97374,28 +91619,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeH265CreateFlagsEXT const &,
+               const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, pStdExtensionVersion );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -97419,29 +91676,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265SessionCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT const &
-                            videoEncodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeH265CreateFlagsEXT, seed, videoEncodeH265SessionCreateInfoEXT.flags );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
-                             seed,
-                             videoEncodeH265SessionCreateInfoEXT.pStdExtensionVersion );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -97587,29 +91821,44 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const StdVideoH265VideoParameterSet * const &,
+               uint32_t const &,
+               const StdVideoH265SequenceParameterSet * const &,
+               uint32_t const &,
+               const StdVideoH265PictureParameterSet * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, vpsStdCount, pVpsStd, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsStdCount == rhs.vpsStdCount ) &&
-             ( pVpsStd == rhs.pVpsStd ) && ( spsStdCount == rhs.spsStdCount ) && ( pSpsStd == rhs.pSpsStd ) &&
-             ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -97638,34 +91887,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265SessionParametersAddInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const &
-                            videoEncodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersAddInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersAddInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.vpsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH265VideoParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pVpsStd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.spsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH265SequenceParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pSpsStd );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.ppsStdCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoH265PictureParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pPpsStd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -97747,29 +91968,42 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, maxVpsStdCount, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVpsStdCount == rhs.maxVpsStdCount ) &&
-             ( maxSpsStdCount == rhs.maxSpsStdCount ) && ( maxPpsStdCount == rhs.maxPpsStdCount ) &&
-             ( pParametersAddInfo == rhs.pParametersAddInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -97796,31 +92030,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265SessionParametersCreateInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const &
-                            videoEncodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersCreateInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersCreateInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxVpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxSpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxPpsStdCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT *,
-                             seed,
-                             videoEncodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -97920,29 +92129,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT *>( this );
     }
 
-    operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT * const &,
+               const StdVideoEncodeH265PictureInfo * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) &&
-             ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) &&
-             ( pCurrentPictureInfo == rhs.pCurrentPictureInfo );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -97968,33 +92191,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265VclFrameInfoEXT;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const & videoEncodeH265VclFrameInfoEXT )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265VclFrameInfoEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265VclFrameInfoEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *,
-                             seed,
-                             videoEncodeH265VclFrameInfoEXT.pReferenceFinalLists );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265VclFrameInfoEXT.naluSliceEntryCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT *,
-                             seed,
-                             videoEncodeH265VclFrameInfoEXT.pNaluSliceEntries );
-    VULKAN_HPP_HASH_COMBINE(
-      const StdVideoEncodeH265PictureInfo *, seed, videoEncodeH265VclFrameInfoEXT.pCurrentPictureInfo );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -98168,34 +92364,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeInfoKHR *>( this );
     }
 
-    operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Buffer const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::DeviceSize const &,
+               VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const &,
+               const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       flags,
+                       qualityLevel,
+                       codedExtent,
+                       dstBitstreamBuffer,
+                       dstBitstreamBufferOffset,
+                       dstBitstreamBufferMaxRange,
+                       srcPictureResource,
+                       pSetupReferenceSlot,
+                       referenceSlotCount,
+                       pReferenceSlots,
+                       precedingExternallyEncodedBytes );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( qualityLevel == rhs.qualityLevel ) && ( codedExtent == rhs.codedExtent ) &&
-             ( dstBitstreamBuffer == rhs.dstBitstreamBuffer ) &&
-             ( dstBitstreamBufferOffset == rhs.dstBitstreamBufferOffset ) &&
-             ( dstBitstreamBufferMaxRange == rhs.dstBitstreamBufferMaxRange ) &&
-             ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) &&
-             ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) &&
-             ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -98226,38 +92449,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR, seed, videoEncodeInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.qualityLevel );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeInfoKHR.codedExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoEncodeInfoKHR.dstBitstreamBuffer );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferOffset );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferMaxRange );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoEncodeInfoKHR.srcPictureResource );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pSetupReferenceSlot );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.referenceSlotCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pReferenceSlots );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -98353,31 +92544,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR *>( this );
     }
 
-    operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       averageBitrate,
+                       maxBitrate,
+                       frameRateNumerator,
+                       frameRateDenominator,
+                       virtualBufferSizeInMs,
+                       initialVirtualBufferSizeInMs );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) &&
-             ( maxBitrate == rhs.maxBitrate ) && ( frameRateNumerator == rhs.frameRateNumerator ) &&
-             ( frameRateDenominator == rhs.frameRateDenominator ) &&
-             ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) &&
-             ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -98405,30 +92616,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeRateControlLayerInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const &
-                            videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlLayerInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlLayerInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.averageBitrate );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.maxBitrate );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.virtualBufferSizeInMs );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.initialVirtualBufferSizeInMs );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -98528,29 +92715,42 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>( this );
     }
 
-    operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEncodeRateControlInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR const &,
+               uint8_t const &,
+               const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayerConfigs );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( rateControlMode == rhs.rateControlMode ) && ( layerCount == rhs.layerCount ) &&
-             ( pLayerConfigs == rhs.pLayerConfigs );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -98577,33 +92777,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeRateControlInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR, seed, videoEncodeRateControlInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR,
-                             seed,
-                             videoEncodeRateControlInfoKHR.rateControlMode );
-    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeRateControlInfoKHR.layerCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR *,
-                             seed,
-                             videoEncodeRateControlInfoKHR.pLayerConfigs );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -98650,27 +92823,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEndCodingInfoKHR *>( this );
     }
 
-    operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoEndCodingInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEndCodingInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -98691,25 +92876,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEndCodingInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEndCodingInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEndCodingInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR, seed, videoEndCodingInfoKHR.flags );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -98741,27 +92907,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoFormatPropertiesKHR *>( this );
     }
 
-    operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoFormatPropertiesKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Format const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, format );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoFormatPropertiesKHR const & ) const = default;
 #  else
     bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -98783,25 +92959,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoFormatPropertiesKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoFormatPropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, videoFormatPropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoFormatPropertiesKHR.format );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -98858,28 +93015,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoGetMemoryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoGetMemoryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoGetMemoryPropertiesKHR *>( this );
     }
 
-    operator VkVideoGetMemoryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoGetMemoryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::MemoryRequirements2 * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, memoryBindIndex, pMemoryRequirements );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoGetMemoryPropertiesKHR const & ) const = default;
 #  else
     bool operator==( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) &&
-             ( pMemoryRequirements == rhs.pMemoryRequirements );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -98903,27 +93072,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoGetMemoryPropertiesKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR const & videoGetMemoryPropertiesKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoGetMemoryPropertiesKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoGetMemoryPropertiesKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoGetMemoryPropertiesKHR.memoryBindIndex );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *, seed, videoGetMemoryPropertiesKHR.pMemoryRequirements );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -98972,27 +93120,39 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoQueueFamilyProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoQueueFamilyProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoQueueFamilyProperties2KHR *>( this );
     }
 
-    operator VkVideoQueueFamilyProperties2KHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoQueueFamilyProperties2KHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoQueueFamilyProperties2KHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, videoCodecOperations );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoQueueFamilyProperties2KHR const & ) const = default;
 #  else
     bool operator==( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -99015,26 +93175,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoQueueFamilyProperties2KHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR const & videoQueueFamilyProperties2KHR )
-    const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoQueueFamilyProperties2KHR.sType );
-    VULKAN_HPP_HASH_COMBINE( void *, seed, videoQueueFamilyProperties2KHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR, seed, videoQueueFamilyProperties2KHR.videoCodecOperations );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -99145,32 +93285,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( this );
     }
 
-    operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoSessionCreateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR const &,
+               const VULKAN_HPP_NAMESPACE::VideoProfileKHR * const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               VULKAN_HPP_NAMESPACE::Extent2D const &,
+               VULKAN_HPP_NAMESPACE::Format const &,
+               uint32_t const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       queueFamilyIndex,
+                       flags,
+                       pVideoProfile,
+                       pictureFormat,
+                       maxCodedExtent,
+                       referencePicturesFormat,
+                       maxReferencePicturesSlotsCount,
+                       maxReferencePicturesActiveCount );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
-             ( flags == rhs.flags ) && ( pVideoProfile == rhs.pVideoProfile ) &&
-             ( pictureFormat == rhs.pictureFormat ) && ( maxCodedExtent == rhs.maxCodedExtent ) &&
-             ( referencePicturesFormat == rhs.referencePicturesFormat ) &&
-             ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) &&
-             ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -99199,33 +93362,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoSessionCreateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.queueFamilyIndex );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR, seed, videoSessionCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoSessionCreateInfoKHR.pVideoProfile );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.pictureFormat );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoSessionCreateInfoKHR.maxCodedExtent );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.referencePicturesFormat );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesSlotsCount );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesActiveCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -99285,29 +93421,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( this );
     }
 
-    operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoSessionParametersCreateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &,
+               VULKAN_HPP_NAMESPACE::VideoSessionKHR const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, videoSessionParametersTemplate, videoSession );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) &&
-             ( videoSession == rhs.videoSession );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -99331,29 +93478,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoSessionParametersCreateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &
-                            videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR,
-                             seed,
-                             videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoSessionParametersCreateInfoKHR.videoSession );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -99403,27 +93527,37 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( this );
     }
 
-    operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkVideoSessionParametersUpdateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, updateSequenceCount );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -99446,25 +93580,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoSessionParametersUpdateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const &
-                            videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersUpdateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersUpdateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
@@ -99527,28 +93642,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( this );
     }
 
-    operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR const &,
+               struct wl_display * const &,
+               struct wl_surface * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, display, surface );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) &&
-             ( surface == rhs.surface );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -99573,28 +93701,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = WaylandSurfaceCreateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, waylandSurfaceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, waylandSurfaceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR, seed, waylandSurfaceCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( struct wl_display *, seed, waylandSurfaceCreateInfoKHR.display );
-    VULKAN_HPP_HASH_COMBINE( struct wl_surface *, seed, waylandSurfaceCreateInfoKHR.surface );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -99805,30 +93911,53 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>( this );
     }
 
-    operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+               const uint64_t * const &,
+               const uint32_t * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+               const uint64_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       acquireCount,
+                       pAcquireSyncs,
+                       pAcquireKeys,
+                       pAcquireTimeouts,
+                       releaseCount,
+                       pReleaseSyncs,
+                       pReleaseKeys );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default;
 #  else
     bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) &&
-             ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) &&
-             ( pAcquireTimeouts == rhs.pAcquireTimeouts ) && ( releaseCount == rhs.releaseCount ) &&
-             ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -99857,33 +93986,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = Win32KeyedMutexAcquireReleaseInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const &
-                            win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -100095,31 +94197,53 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>( this );
     }
 
-    operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+               const uint64_t * const &,
+               const uint32_t * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+               const uint64_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       acquireCount,
+                       pAcquireSyncs,
+                       pAcquireKeys,
+                       pAcquireTimeoutMilliseconds,
+                       releaseCount,
+                       pReleaseSyncs,
+                       pReleaseKeys );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default;
 #  else
     bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) &&
-             ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) &&
-             ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) &&
-             ( releaseCount == rhs.releaseCount ) && ( pReleaseSyncs == rhs.pReleaseSyncs ) &&
-             ( pReleaseKeys == rhs.pReleaseKeys );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -100148,33 +94272,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = Win32KeyedMutexAcquireReleaseInfoNV;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const &
-                            win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys );
-    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount );
-    VULKAN_HPP_HASH_COMBINE(
-      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs );
-    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -100237,28 +94334,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( this );
     }
 
-    operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR const &,
+               HINSTANCE const &,
+               HWND const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, hinstance, hwnd );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -100282,27 +94392,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = Win32SurfaceCreateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32SurfaceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, win32SurfaceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR, seed, win32SurfaceCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( HINSTANCE, seed, win32SurfaceCreateInfoKHR.hinstance );
-    VULKAN_HPP_HASH_COMBINE( HWND, seed, win32SurfaceCreateInfoKHR.hwnd );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct WriteDescriptorSet
@@ -100476,31 +94565,55 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWriteDescriptorSet *>( this );
     }
 
-    operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWriteDescriptorSet *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::DescriptorSet const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::DescriptorType const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorImageInfo * const &,
+               const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo * const &,
+               const VULKAN_HPP_NAMESPACE::BufferView * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       dstSet,
+                       dstBinding,
+                       dstArrayElement,
+                       descriptorCount,
+                       descriptorType,
+                       pImageInfo,
+                       pBufferInfo,
+                       pTexelBufferView );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSet const & ) const = default;
 #else
     bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dstSet == rhs.dstSet ) &&
-             ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) &&
-             ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) &&
-             ( pImageInfo == rhs.pImageInfo ) && ( pBufferInfo == rhs.pBufferInfo ) &&
-             ( pTexelBufferView == rhs.pTexelBufferView );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -100529,31 +94642,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSet;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
-{
-  std::size_t
-    operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSet.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSet.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, writeDescriptorSet.dstSet );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstBinding );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstArrayElement );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.descriptorCount );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, writeDescriptorSet.descriptorType );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorImageInfo *, seed, writeDescriptorSet.pImageInfo );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo *, seed, writeDescriptorSet.pBufferInfo );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferView *, seed, writeDescriptorSet.pTexelBufferView );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct WriteDescriptorSetAccelerationStructureKHR
   {
     using NativeType = VkWriteDescriptorSetAccelerationStructureKHR;
@@ -100633,29 +94721,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>( this );
     }
 
-    operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default;
 #else
     bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
-             ( pAccelerationStructures == rhs.pAccelerationStructures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -100681,28 +94780,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSetAccelerationStructureKHR;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const &
-                            writeDescriptorSetAccelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *,
-                             seed,
-                             writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct WriteDescriptorSetAccelerationStructureNV
   {
     using NativeType = VkWriteDescriptorSetAccelerationStructureNV;
@@ -100782,29 +94859,40 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>( this );
     }
 
-    operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default;
 #else
     bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
-             ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
-             ( pAccelerationStructures == rhs.pAccelerationStructures );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -100830,28 +94918,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSetAccelerationStructureNV;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const &
-                            writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE(
-      VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureNV.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureNV.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount );
-    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureNV *,
-                             seed,
-                             writeDescriptorSetAccelerationStructureNV.pAccelerationStructures );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
   struct WriteDescriptorSetInlineUniformBlockEXT
   {
     using NativeType = VkWriteDescriptorSetInlineUniformBlockEXT;
@@ -100927,27 +94993,38 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkWriteDescriptorSetInlineUniformBlockEXT const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSetInlineUniformBlockEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT *>( this );
     }
 
-    operator VkWriteDescriptorSetInlineUniformBlockEXT &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkWriteDescriptorSetInlineUniformBlockEXT &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT *>( this );
     }
 
+#if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#else
+    std::
+      tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, const void * const &>
+#endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, dataSize, pData );
+    }
+
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const & ) const = default;
 #else
     bool operator==( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #endif
 
@@ -100973,25 +95050,6 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSetInlineUniformBlockEXT;
   };
 
-}  // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT const &
-                            writeDescriptorSetInlineUniformBlockEXT ) const VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetInlineUniformBlockEXT.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pNext );
-    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetInlineUniformBlockEXT.dataSize );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pData );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #if defined( VK_USE_PLATFORM_XCB_KHR )
   struct XcbSurfaceCreateInfoKHR
   {
@@ -101052,28 +95110,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( this );
     }
 
-    operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR const &,
+               xcb_connection_t * const &,
+               xcb_window_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, connection, window );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( XcbSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
-             ( connection == rhs.connection ) && ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -101097,27 +95168,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = XcbSurfaceCreateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xcbSurfaceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, xcbSurfaceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR, seed, xcbSurfaceCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( xcb_connection_t *, seed, xcbSurfaceCreateInfoKHR.connection );
-    VULKAN_HPP_HASH_COMBINE( xcb_window_t, seed, xcbSurfaceCreateInfoKHR.window );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
 
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
@@ -101179,28 +95229,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    explicit operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( this );
     }
 
-    operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    explicit operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>( this );
     }
 
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR const &,
+               Display * const &,
+               Window const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, flags, dpy, window );
+    }
+
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( XlibSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) &&
-             ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 );
+      return this->reflect() == rhs.reflect();
     }
 
     bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return !operator==( rhs );
+      return this->reflect() != rhs.reflect();
     }
 #  endif
 
@@ -101224,27 +95287,6 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = XlibSurfaceCreateInfoKHR;
   };
-
-}  // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR>
-{
-  std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const
-    VULKAN_HPP_NOEXCEPT
-  {
-    std::size_t seed = 0;
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xlibSurfaceCreateInfoKHR.sType );
-    VULKAN_HPP_HASH_COMBINE( const void *, seed, xlibSurfaceCreateInfoKHR.pNext );
-    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR, seed, xlibSurfaceCreateInfoKHR.flags );
-    VULKAN_HPP_HASH_COMBINE( Display *, seed, xlibSurfaceCreateInfoKHR.dpy );
-    VULKAN_HPP_HASH_COMBINE( Window, seed, xlibSurfaceCreateInfoKHR.window );
-    return seed;
-  }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
 }  // namespace VULKAN_HPP_NAMESPACE
diff --git a/registry/generator.py b/registry/generator.py
index ad07c38..0c2a408 100644
--- a/registry/generator.py
+++ b/registry/generator.py
@@ -55,10 +55,13 @@ def regSortCategoryKey(feature):
     Sorts by category of the feature name string:
 
     - Core API features (those defined with a `<feature>` tag)
+        - (sort VKSC after VK)
     - ARB/KHR/OES (Khronos extensions)
     - other       (EXT/vendor extensions)"""
 
     if feature.elem.tag == 'feature':
+        if feature.name.startswith('VKSC'):
+            return 0.5
         return 0
     if (feature.category == 'ARB'
         or feature.category == 'KHR'
@@ -1063,7 +1066,8 @@ class OutputGenerator:
             return False
 
         info = self.registry.typedict.get(structname)
-        assert(info is not None)
+        if info is None:
+            self.logMsg('error', f'isStructAlwaysValid({structname}) - structure not found in typedict')
 
         members = info.getMembers()
 
diff --git a/registry/genvk.py b/registry/genvk.py
index 95dc0d4..150b348 100755
--- a/registry/genvk.py
+++ b/registry/genvk.py
@@ -511,6 +511,83 @@ def makeGenOpts(args):
             misracppstyle     = misracppstyle)
         ]
 
+    # Video header target - combines all video extension dependencies into a
+    # single header, at present.
+    genOpts['vk_video.h'] = [
+          COutputGenerator,
+          CGeneratorOptions(
+            conventions       = conventions,
+            filename          = 'vk_video.h',
+            directory         = directory,
+            genpath           = None,
+            apiname           = 'vulkan',
+            profile           = None,
+            versions          = None,
+            emitversions      = None,
+            defaultExtensions = defaultExtensions,
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = removeExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = '',
+            apientry          = '',
+            apientryp         = '',
+            alignFuncParam    = 48,
+            misracstyle       = misracstyle,
+            misracppstyle     = misracppstyle)
+    ]
+
+    # Video extension 'Std' interfaces, each in its own header files
+    # These are not Vulkan extensions, or a part of the Vulkan API at all,
+    # but are treated in a similar fashion for generation purposes.
+    #
+    # Each element of the videoStd[] array is an 'extension' name defining
+    # an iterface, and is also the basis for the generated header file name.
+
+    videoStd = [
+        'vulkan_video_codecs_common',
+        'vulkan_video_codec_h264std',
+        'vulkan_video_codec_h264std_decode',
+        'vulkan_video_codec_h264std_encode',
+        'vulkan_video_codec_h265std',
+        'vulkan_video_codec_h265std_decode',
+        'vulkan_video_codec_h265std_encode',
+    ]
+
+    addExtensionRE = makeREstring(videoStd)
+    for codec in videoStd:
+        headername = f'{codec}.h'
+
+        # Consider all of the codecs 'extensions', but only emit this one
+        emitExtensionRE = makeREstring([codec])
+
+        opts = CGeneratorOptions(
+            conventions       = conventions,
+            filename          = headername,
+            directory         = directory,
+            genpath           = None,
+            apiname           = defaultAPIName,
+            profile           = None,
+            versions          = None,
+            emitversions      = None,
+            defaultExtensions = None,
+            addExtensions     = addExtensionRE,
+            removeExtensions  = None,
+            emitExtensions    = emitExtensionRE,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = False,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            alignFuncParam    = 48,
+            )
+
+        genOpts[headername] = [ COutputGenerator, opts ]
+
     # Unused - vulkan11.h target.
     # It is possible to generate a header with just the Vulkan 1.0 +
     # extension interfaces defined, but since the promoted KHR extensions
diff --git a/registry/reg.py b/registry/reg.py
index 6eec554..aeef363 100644
--- a/registry/reg.py
+++ b/registry/reg.py
@@ -104,13 +104,14 @@ def stripNonmatchingAPIs(tree, apiName, actuallyDelete = True):
 
         for child in parent.findall('*'):
             api = child.get('api')
-            if api:
-                if not apiNameMatch(apiName, api):
-                    if actuallyDelete:
-                        parent.remove(child)
-            else:
+
+            if apiNameMatch(apiName, api):
                 # Add child to the queue
                 stack.append(child)
+            elif not apiNameMatch(apiName, api):
+                # Child does not match requested api. Remove it.
+                if actuallyDelete:
+                    parent.remove(child)
 
 
 class BaseInfo:
@@ -403,22 +404,15 @@ class Registry:
         - infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' / 'spirvextension' / 'spirvcapability' / 'format'
         - dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap}dict
 
-        If the Element has an 'api' attribute, the dictionary key is the
-        tuple (name,api). If not, the key is the name. 'name' is an
-        attribute of the Element"""
+        The dictionary key is the element 'name' attribute."""
+
         # self.gen.logMsg('diag', 'Adding ElementInfo.required =',
         #     info.required, 'name =', elem.get('name'))
-        api = elem.get('api')
-        if api:
-            key = (elem.get('name'), api)
-        else:
-            key = elem.get('name')
+        key = elem.get('name')
         if key in dictionary:
             if not dictionary[key].compareElem(info, infoName):
                 self.gen.logMsg('warn', 'Attempt to redefine', key,
                                 '(this should not happen)')
-            else:
-                True
         else:
             dictionary[key] = info
 
@@ -459,7 +453,7 @@ class Registry:
         # overlapping api attributes, or where one element has an api
         # attribute and the other does not.
 
-        stripNonmatchingAPIs(self.reg, self.genOpts.apiname)
+        stripNonmatchingAPIs(self.reg, self.genOpts.apiname, actuallyDelete = True)
 
         # Create dictionary of registry types from toplevel <types> tags
         # and add 'name' attribute to each <type> tag (where missing)
@@ -720,6 +714,7 @@ class Registry:
         - required - boolean (to tag features as required or not)
         """
         self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required)
+
         # Get TypeInfo object for <type> tag corresponding to typename
         typeinfo = self.lookupElementInfo(typename, self.typedict)
         if typeinfo is not None:
@@ -774,20 +769,18 @@ class Registry:
         - enumname - name of enum
         - required - boolean (to tag features as required or not)"""
 
-        self.gen.logMsg('diag', 'tagging enum:', enumname, '-> required =', required)
+        self.gen.logMsg('diag', 'markEnumRequired: tagging enum:', enumname, '-> required =', required)
         enum = self.lookupElementInfo(enumname, self.enumdict)
         if enum is not None:
             # If the enum is part of a group, and is being removed, then
-            # look it up in that <group> tag and remove it there, so that it
-            # is not visible to generators (which traverse the <group> tag
-            # elements themselves).
-            # This is not the most robust way of doing this, since a removed
-            # enum that is later required again will no longer have a group
-            # element, but it makes the change non-intrusive on generator
-            # code.
-            if required is False:
+            # look it up in that <enums> tag and remove the Element there,
+            # so that it is not visible to generators (which traverse the
+            # <enums> tag elements rather than using the dictionaries).
+            if not required:
                 groupName = enum.elem.get('extends')
                 if groupName is not None:
+                    self.gen.logMsg('diag', f'markEnumRequired: Removing extending enum {enum.elem.get("name")}')
+
                     # Look up the Info with matching groupName
                     if groupName in self.groupdict:
                         gi = self.groupdict[groupName]
@@ -796,23 +789,42 @@ class Registry:
                             # Remove copy of this enum from the group
                             gi.elem.remove(gienum)
                         else:
-                            self.gen.logMsg('warn', 'Cannot remove enum',
+                            self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
                                             enumname, 'not found in group',
                                             groupName)
                     else:
-                        self.gen.logMsg('warn', 'Cannot remove enum',
+                        self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
                                         enumname, 'from nonexistent group',
                                         groupName)
+                else:
+                    # This enum is not an extending enum.
+                    # The XML tree must be searched for all <enums> that
+                    # might have it, so we know the parent to delete from.
+
+                    enumName = enum.elem.get('name')
+
+                    self.gen.logMsg('diag', f'markEnumRequired: Removing non-extending enum {enumName}')
+
+                    count = 0
+                    for enums in self.reg.findall('enums'):
+                        for thisEnum in enums.findall('enum'):
+                            if thisEnum.get('name') == enumName:
+                                # Actually remove it
+                                count = count + 1
+                                enums.remove(thisEnum)
+
+                    if count == 0:
+                        self.gen.logMsg('warn', f'markEnumRequired: {enumName}) not found in any <enums> tag')
 
             enum.required = required
             # Tag enum dependencies in 'alias' attribute as required
             depname = enum.elem.get('alias')
             if depname:
-                self.gen.logMsg('diag', 'Generating dependent enum',
+                self.gen.logMsg('diag', 'markEnumRequired: Generating dependent enum',
                                 depname, 'for alias', enumname, 'required =', enum.required)
                 self.markEnumRequired(depname, required)
         else:
-            self.gen.logMsg('warn', 'enum:', enumname, 'IS NOT DEFINED')
+            self.gen.logMsg('warn', f'markEnumRequired: {enumname} IS NOT DEFINED')
 
     def markCmdRequired(self, cmdname, required):
         """Mark a command as required or not.
@@ -869,6 +881,7 @@ class Registry:
             self.markTypeRequired(typeElem.get('name'), required)
         for enumElem in feature.findall('enum'):
             self.markEnumRequired(enumElem.get('name'), required)
+
         for cmdElem in feature.findall('command'):
             self.markCmdRequired(cmdElem.get('name'), required)
 
@@ -1009,11 +1022,11 @@ class Registry:
                     else:
                         self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
 
-    def requireAndRemoveFeatures(self, interface, featurename, api, profile):
-        """Process `<require>` and `<remove>` tags for a `<version>` or `<extension>`.
+    def requireFeatures(self, interface, featurename, api, profile):
+        """Process `<require>` tags for a `<version>` or `<extension>`.
 
         - interface - Element for `<version>` or `<extension>`, containing
-          `<require>` and `<remove>` tags
+          `<require>` tags
         - featurename - name of the feature
         - api - string specifying API name being generated
         - profile - string specifying API profile being generated"""
@@ -1023,6 +1036,15 @@ class Registry:
             if matchAPIProfile(api, profile, feature):
                 self.markRequired(featurename, feature, True)
 
+    def removeFeatures(self, interface, featurename, api, profile):
+        """Process `<remove>` tags for a `<version>` or `<extension>`.
+
+        - interface - Element for `<version>` or `<extension>`, containing
+          `<remove>` tags
+        - featurename - name of the feature
+        - api - string specifying API name being generated
+        - profile - string specifying API profile being generated"""
+
         # <remove> marks things that are removed by this version/profile
         for feature in interface.findall('remove'):
             if matchAPIProfile(api, profile, feature):
@@ -1038,6 +1060,7 @@ class Registry:
                     if v.get('struct'):
                         self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v))
 
+    def removeAdditionalValidity(self, interface, api, profile):
         # Loop over all usage inside all <remove> tags.
         for feature in interface.findall('remove'):
             if matchAPIProfile(api, profile, feature):
@@ -1165,7 +1188,8 @@ class Registry:
                         if extname is not None:
                             # 'supported' attribute was injected when the <enum> element was
                             # moved into the <enums> group in Registry.parseTree()
-                            if self.genOpts.defaultExtensions == elem.get('supported'):
+                            supported_list = elem.get('supported').split(",")
+                            if self.genOpts.defaultExtensions in supported_list:
                                 required = True
                             elif re.match(self.genOpts.addExtensions, extname) is not None:
                                 required = True
@@ -1353,7 +1377,7 @@ class Registry:
 
         # Get all matching extensions, in order by their extension number,
         # and add to the list of features.
-        # Start with extensions tagged with 'api' pattern matching the API
+        # Start with extensions whose 'supported' attributes match the API
         # being generated. Add extensions matching the pattern specified in
         # regExtensions, then remove extensions matching the pattern
         # specified in regRemoveExtensions
@@ -1435,22 +1459,25 @@ class Registry:
             self.genOpts.sortProcedure(features)
             # print('sortProcedure ->', [f.name for f in features])
 
-        # Pass 1: loop over requested API versions and extensions tagging
+        # Passes 1+2: loop over requested API versions and extensions tagging
         #   types/commands/features as required (in an <require> block) or no
-        #   longer required (in an <remove> block). It is possible to remove
-        #   a feature in one version and restore it later by requiring it in
-        #   a later version.
+        #   longer required (in an <remove> block). <remove>s are processed
+        #   after all <require>s, so removals win.
         # If a profile other than 'None' is being generated, it must
         #   match the profile attribute (if any) of the <require> and
         #   <remove> tags.
         self.gen.logMsg('diag', 'PASS 1: TAG FEATURES')
         for f in features:
-            self.gen.logMsg('diag', 'PASS 1: Tagging required and removed features for',
-                            f.name)
+            self.gen.logMsg('diag', 'PASS 1: Tagging required and features for', f.name)
             self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
-            self.requireAndRemoveFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
+            self.requireFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
             self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
 
+        for f in features:
+            self.gen.logMsg('diag', 'PASS 2: Tagging removed features for', f.name)
+            self.removeFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
+            self.removeAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
+
         # Now, strip references to APIs that are not required.
         # At present such references may occur in:
         #   Structs in <type category="struct"> 'structextends' attributes
@@ -1466,17 +1493,17 @@ class Registry:
         #   <enable extension="VK_KHR_shader_draw_parameters"/>
         #   <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormPreserveFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
 
-        # Pass 2: loop over specified API versions and extensions printing
+        # Pass 3: loop over specified API versions and extensions printing
         #   declarations for required things which have not already been
         #   generated.
-        self.gen.logMsg('diag', 'PASS 2: GENERATE INTERFACES FOR FEATURES')
+        self.gen.logMsg('diag', 'PASS 3: GENERATE INTERFACES FOR FEATURES')
         self.gen.beginFile(self.genOpts)
         for f in features:
-            self.gen.logMsg('diag', 'PASS 2: Generating interface for',
+            self.gen.logMsg('diag', 'PASS 3: Generating interface for',
                             f.name)
             emit = self.emitFeatures = f.emit
             if not emit:
-                self.gen.logMsg('diag', 'PASS 2: NOT declaring feature',
+                self.gen.logMsg('diag', 'PASS 3: NOT declaring feature',
                                 f.elem.get('name'), 'because it is not tagged for emission')
             # Generate the interface (or just tag its elements as having been
             # emitted, if they have not been).
diff --git a/registry/validusage.json b/registry/validusage.json
index 856fa2a..29de1ea 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.202",
-    "comment": "from git branch: github-main commit: 48b76697118c275337e49836259f0571b3410d84",
-    "date": "2021-12-07 08:44:26Z"
+    "api version": "1.2.203",
+    "comment": "from git branch: github-main commit: ac23aa229fd9b8ea06aa99cf07b79cdc15af406f",
+    "date": "2021-12-20 11:55:32Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -238,7 +238,7 @@
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceAccelerationStructurePropertiesKHR\">VkPhysicalDeviceAccelerationStructurePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesNV\">VkPhysicalDeviceCooperativeMatrixPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorPropertiesEXT\">VkPhysicalDeviceCustomBorderColorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDepthStencilResolveProperties\">VkPhysicalDeviceDepthStencilResolveProperties</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingProperties\">VkPhysicalDeviceDescriptorIndexingProperties</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverProperties\">VkPhysicalDeviceDriverProperties</a>, <a href=\"#VkPhysicalDeviceDrmPropertiesEXT\">VkPhysicalDeviceDrmPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsProperties\">VkPhysicalDeviceFloatControlsProperties</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2PropertiesEXT\">VkPhysicalDeviceFragmentDensityMap2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV\">VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRatePropertiesKHR\">VkPhysicalDeviceFragmentShadingRatePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationPropertiesEXT\">VkPhysicalDeviceLineRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMaintenance4PropertiesKHR\">VkPhysicalDeviceMaintenance4PropertiesKHR</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawPropertiesEXT\">VkPhysicalDeviceMultiDrawPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetPropertiesKHR\">VkPhysicalDevicePortabilitySubsetPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDeviceProvokingVertexPropertiesEXT\">VkPhysicalDeviceProvokingVertexPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelinePropertiesKHR\">VkPhysicalDeviceRayTracingPipelinePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2PropertiesEXT\">VkPhysicalDeviceRobustness2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxProperties\">VkPhysicalDeviceSamplerFilterMinmaxProperties</a>, <a href=\"#VkPhysicalDeviceShaderCoreProperties2AMD\">VkPhysicalDeviceShaderCoreProperties2AMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR\">VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\">VkPhysicalDeviceShaderSMBuiltinsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlPropertiesEXT\">VkPhysicalDeviceSubgroupSizeControlPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSubpassShadingPropertiesHUAWEI\">VkPhysicalDeviceSubpassShadingPropertiesHUAWEI</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreProperties\">VkPhysicalDeviceTimelineSemaphoreProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Properties\">VkPhysicalDeviceVulkan11Properties</a>, or <a href=\"#VkPhysicalDeviceVulkan12Properties\">VkPhysicalDeviceVulkan12Properties</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceAccelerationStructurePropertiesKHR\">VkPhysicalDeviceAccelerationStructurePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesNV\">VkPhysicalDeviceCooperativeMatrixPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorPropertiesEXT\">VkPhysicalDeviceCustomBorderColorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDepthStencilResolveProperties\">VkPhysicalDeviceDepthStencilResolveProperties</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingProperties\">VkPhysicalDeviceDescriptorIndexingProperties</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverProperties\">VkPhysicalDeviceDriverProperties</a>, <a href=\"#VkPhysicalDeviceDrmPropertiesEXT\">VkPhysicalDeviceDrmPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsProperties\">VkPhysicalDeviceFloatControlsProperties</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2PropertiesEXT\">VkPhysicalDeviceFragmentDensityMap2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM\">VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV\">VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRatePropertiesKHR\">VkPhysicalDeviceFragmentShadingRatePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationPropertiesEXT\">VkPhysicalDeviceLineRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMaintenance4PropertiesKHR\">VkPhysicalDeviceMaintenance4PropertiesKHR</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawPropertiesEXT\">VkPhysicalDeviceMultiDrawPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetPropertiesKHR\">VkPhysicalDevicePortabilitySubsetPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDeviceProvokingVertexPropertiesEXT\">VkPhysicalDeviceProvokingVertexPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelinePropertiesKHR\">VkPhysicalDeviceRayTracingPipelinePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2PropertiesEXT\">VkPhysicalDeviceRobustness2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxProperties\">VkPhysicalDeviceSamplerFilterMinmaxProperties</a>, <a href=\"#VkPhysicalDeviceShaderCoreProperties2AMD\">VkPhysicalDeviceShaderCoreProperties2AMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR\">VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\">VkPhysicalDeviceShaderSMBuiltinsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlPropertiesEXT\">VkPhysicalDeviceSubgroupSizeControlPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSubpassShadingPropertiesHUAWEI\">VkPhysicalDeviceSubpassShadingPropertiesHUAWEI</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreProperties\">VkPhysicalDeviceTimelineSemaphoreProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Properties\">VkPhysicalDeviceVulkan11Properties</a>, or <a href=\"#VkPhysicalDeviceVulkan12Properties\">VkPhysicalDeviceVulkan12Properties</a>"
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique",
@@ -342,7 +342,7 @@
         },
         {
           "vuid": "VUID-VkQueueFamilyProperties2-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkQueueFamilyCheckpointProperties2NV\">VkQueueFamilyCheckpointProperties2NV</a>, <a href=\"#VkQueueFamilyCheckpointPropertiesNV\">VkQueueFamilyCheckpointPropertiesNV</a>, <a href=\"#VkQueueFamilyGlobalPriorityPropertiesEXT\">VkQueueFamilyGlobalPriorityPropertiesEXT</a>, or <a href=\"#VkVideoQueueFamilyProperties2KHR\">VkVideoQueueFamilyProperties2KHR</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkQueueFamilyCheckpointProperties2NV\">VkQueueFamilyCheckpointProperties2NV</a>, <a href=\"#VkQueueFamilyCheckpointPropertiesNV\">VkQueueFamilyCheckpointPropertiesNV</a>, <a href=\"#VkQueueFamilyGlobalPriorityPropertiesEXT\">VkQueueFamilyGlobalPriorityPropertiesEXT</a>, <a href=\"#VkQueueFamilyQueryResultStatusProperties2KHR\">VkQueueFamilyQueryResultStatusProperties2KHR</a>, or <a href=\"#VkVideoQueueFamilyProperties2KHR\">VkVideoQueueFamilyProperties2KHR</a>"
         },
         {
           "vuid": "VUID-VkQueueFamilyProperties2-sType-unique",
@@ -529,44 +529,44 @@
       ],
       "(VK_VERSION_1_2)+(VK_KHR_shader_draw_parameters)": [
         {
-          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-04476",
-          "text": " If <code>ppEnabledExtensions</code> contains <code>\"VK_KHR_shader_draw_parameters\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a> structure, then <code>VkPhysicalDeviceVulkan11Features</code>::<code>shaderDrawParameters</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
+          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-04476",
+          "text": " If <code>ppEnabledExtensionNames</code> contains <code>\"VK_KHR_shader_draw_parameters\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a> structure, then <code>VkPhysicalDeviceVulkan11Features</code>::<code>shaderDrawParameters</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
         }
       ],
       "(VK_VERSION_1_2)+(VK_KHR_draw_indirect_count)": [
         {
-          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02831",
-          "text": " If <code>ppEnabledExtensions</code> contains <code>\"VK_KHR_draw_indirect_count\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>drawIndirectCount</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
+          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02831",
+          "text": " If <code>ppEnabledExtensionNames</code> contains <code>\"VK_KHR_draw_indirect_count\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>drawIndirectCount</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
         }
       ],
       "(VK_VERSION_1_2)+(VK_KHR_sampler_mirror_clamp_to_edge)": [
         {
-          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02832",
-          "text": " If <code>ppEnabledExtensions</code> contains <code>\"VK_KHR_sampler_mirror_clamp_to_edge\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>samplerMirrorClampToEdge</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
+          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02832",
+          "text": " If <code>ppEnabledExtensionNames</code> contains <code>\"VK_KHR_sampler_mirror_clamp_to_edge\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>samplerMirrorClampToEdge</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
         }
       ],
       "(VK_VERSION_1_2)+(VK_EXT_descriptor_indexing)": [
         {
-          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02833",
-          "text": " If <code>ppEnabledExtensions</code> contains <code>\"VK_EXT_descriptor_indexing\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>descriptorIndexing</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
+          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02833",
+          "text": " If <code>ppEnabledExtensionNames</code> contains <code>\"VK_EXT_descriptor_indexing\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>descriptorIndexing</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
         }
       ],
       "(VK_VERSION_1_2)+(VK_EXT_sampler_filter_minmax)": [
         {
-          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02834",
-          "text": " If <code>ppEnabledExtensions</code> contains <code>\"VK_EXT_sampler_filter_minmax\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>samplerFilterMinmax</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
+          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02834",
+          "text": " If <code>ppEnabledExtensionNames</code> contains <code>\"VK_EXT_sampler_filter_minmax\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>samplerFilterMinmax</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
         }
       ],
       "(VK_VERSION_1_2)+(VK_EXT_shader_viewport_index_layer)": [
         {
-          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02835",
-          "text": " If <code>ppEnabledExtensions</code> contains <code>\"VK_EXT_shader_viewport_index_layer\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>shaderOutputViewportIndex</code> and <code>VkPhysicalDeviceVulkan12Features</code>::<code>shaderOutputLayer</code> <strong class=\"purple\">must</strong> both be <code>VK_TRUE</code>"
+          "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02835",
+          "text": " If <code>ppEnabledExtensionNames</code> contains <code>\"VK_EXT_shader_viewport_index_layer\"</code> and the <code>pNext</code> chain includes a <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a> structure, then <code>VkPhysicalDeviceVulkan12Features</code>::<code>shaderOutputViewportIndex</code> and <code>VkPhysicalDeviceVulkan12Features</code>::<code>shaderOutputLayer</code> <strong class=\"purple\">must</strong> both be <code>VK_TRUE</code>"
         }
       ],
       "(VK_KHR_portability_subset)": [
         {
           "vuid": "VUID-VkDeviceCreateInfo-pProperties-04451",
-          "text": " If the <code><a href=\"#VK_KHR_portability_subset\">VK_KHR_portability_subset</a></code> extension is included in <code>pProperties</code> of <a href=\"#vkEnumerateDeviceExtensionProperties\">vkEnumerateDeviceExtensionProperties</a>, <code>ppEnabledExtensions</code> <strong class=\"purple\">must</strong> include \"VK_KHR_portability_subset\""
+          "text": " If the <code><a href=\"#VK_KHR_portability_subset\">VK_KHR_portability_subset</a></code> extension is included in <code>pProperties</code> of <a href=\"#vkEnumerateDeviceExtensionProperties\">vkEnumerateDeviceExtensionProperties</a>, <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> include <code>\"VK_KHR_portability_subset\"</code>"
         }
       ],
       "(VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image)": [
@@ -626,7 +626,7 @@
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfoEXT\">VkDevicePrivateDataCreateInfoEXT</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBorderColorSwizzleFeaturesEXT\">VkPhysicalDeviceBorderColorSwizzleFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceColorWriteEnableFeaturesEXT\">VkPhysicalDeviceColorWriteEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipControlFeaturesEXT\">VkPhysicalDeviceDepthClipControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDynamicRenderingFeaturesKHR\">VkPhysicalDeviceDynamicRenderingFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState2FeaturesEXT\">VkPhysicalDeviceExtendedDynamicState2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExternalMemoryRDMAFeaturesNV\">VkPhysicalDeviceExternalMemoryRDMAFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT\">VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeaturesEXT\">VkPhysicalDeviceImageRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageViewMinLodFeaturesEXT\">VkPhysicalDeviceImageViewMinLodFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInheritedViewportScissorFeaturesNV\">VkPhysicalDeviceInheritedViewportScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInvocationMaskFeaturesHUAWEI\">VkPhysicalDeviceInvocationMaskFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance4FeaturesKHR\">VkPhysicalDeviceMaintenance4FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawFeaturesEXT\">VkPhysicalDeviceMultiDrawFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>, <a href=\"#VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT\">VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentIdFeaturesKHR\">VkPhysicalDevicePresentIdFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentWaitFeaturesKHR\">VkPhysicalDevicePresentWaitFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT\">VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePrivateDataFeaturesEXT\">VkPhysicalDevicePrivateDataFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceProvokingVertexFeaturesEXT\">VkPhysicalDeviceProvokingVertexFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT\">VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM\">VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingMotionBlurFeaturesNV\">VkPhysicalDeviceRayTracingMotionBlurFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT\">VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR\">VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR\">VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR\">VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSubpassShadingFeaturesHUAWEI\">VkPhysicalDeviceSubpassShadingFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceSynchronization2FeaturesKHR\">VkPhysicalDeviceSynchronization2FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT\">VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, <a href=\"#VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR\">VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT\">VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR\">VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfoEXT\">VkDevicePrivateDataCreateInfoEXT</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBorderColorSwizzleFeaturesEXT\">VkPhysicalDeviceBorderColorSwizzleFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceColorWriteEnableFeaturesEXT\">VkPhysicalDeviceColorWriteEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipControlFeaturesEXT\">VkPhysicalDeviceDepthClipControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDynamicRenderingFeaturesKHR\">VkPhysicalDeviceDynamicRenderingFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState2FeaturesEXT\">VkPhysicalDeviceExtendedDynamicState2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExternalMemoryRDMAFeaturesNV\">VkPhysicalDeviceExternalMemoryRDMAFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM\">VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT\">VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeaturesEXT\">VkPhysicalDeviceImageRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageViewMinLodFeaturesEXT\">VkPhysicalDeviceImageViewMinLodFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInheritedViewportScissorFeaturesNV\">VkPhysicalDeviceInheritedViewportScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInvocationMaskFeaturesHUAWEI\">VkPhysicalDeviceInvocationMaskFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLinearColorAttachmentFeaturesNV\">VkPhysicalDeviceLinearColorAttachmentFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMaintenance4FeaturesKHR\">VkPhysicalDeviceMaintenance4FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawFeaturesEXT\">VkPhysicalDeviceMultiDrawFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>, <a href=\"#VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT\">VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentIdFeaturesKHR\">VkPhysicalDevicePresentIdFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentWaitFeaturesKHR\">VkPhysicalDevicePresentWaitFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT\">VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePrivateDataFeaturesEXT\">VkPhysicalDevicePrivateDataFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceProvokingVertexFeaturesEXT\">VkPhysicalDeviceProvokingVertexFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT\">VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM\">VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingMotionBlurFeaturesNV\">VkPhysicalDeviceRayTracingMotionBlurFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT\">VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR\">VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR\">VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR\">VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSubpassShadingFeaturesHUAWEI\">VkPhysicalDeviceSubpassShadingFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceSynchronization2FeaturesKHR\">VkPhysicalDeviceSynchronization2FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT\">VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, <a href=\"#VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR\">VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT\">VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR\">VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR</a>"
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-sType-unique",
@@ -1347,6 +1347,12 @@
           "text": " If <code>rasterizationSamples</code> is not <code>0</code>, <code>rasterizationSamples</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value"
         }
       ],
+      "(VK_KHR_dynamic_rendering)+(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-pColorAttachmentFormats-06492",
+          "text": " When rendering to a <a href=\"#glossary\">Linear Color attachment</a>, if any element of <code>pColorAttachmentFormats</code> is not <code>VK_FORMAT_UNDEFINED</code>, it <strong class=\"purple\">must</strong> be a format with <a href=\"#potential-format-features\">potential format features</a> that include <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        }
+      ],
       "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_multiview)": [
         {
           "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-viewMask-06009",
@@ -7489,6 +7495,20 @@
           "text": " If <code>preserveAttachmentCount</code> is not <code>0</code>, <code>pPreserveAttachments</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>preserveAttachmentCount</code> <code>uint32_t</code> values"
         }
       ],
+      "(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-VkSubpassDescription-linearColorAttachment-06496",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, all attachments in <code>pInputAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have image formats whose <a href=\"#potential-format-features\">potential format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription-linearColorAttachment-06497",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, all attachments in <code>pColorAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have image formats whose <a href=\"#potential-format-features\">potential format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription-linearColorAttachment-06498",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, all attachments in <code>pResolveAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have image formats whose <a href=\"#potential-format-features\">potential format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        }
+      ],
       "(VK_AMD_mixed_attachment_samples)": [
         {
           "vuid": "VUID-VkSubpassDescription-pColorAttachments-01506",
@@ -8133,6 +8153,20 @@
           "text": " If <code>preserveAttachmentCount</code> is not <code>0</code>, <code>pPreserveAttachments</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>preserveAttachmentCount</code> <code>uint32_t</code> values"
         }
       ],
+      "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-VkSubpassDescription2-linearColorAttachment-06499",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, all attachments in <code>pInputAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have image formats whose <a href=\"#potential-format-features\">potential format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription2-linearColorAttachment-06500",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, all attachments in <code>pColorAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have image formats whose <a href=\"#potential-format-features\">potential format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription2-linearColorAttachment-06501",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, all attachments in <code>pResolveAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have image formats whose <a href=\"#potential-format-features\">potential format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        }
+      ],
       "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_AMD_mixed_attachment_samples)": [
         {
           "vuid": "VUID-VkSubpassDescription2-pColorAttachments-03070",
@@ -8671,6 +8705,12 @@
           "text": " If <code>renderpass</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <code>flags</code> does not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT</code>, an element of <code>pAttachments</code> that is referenced by <code>fragmentDensityMapAttachment</code> <strong class=\"purple\">must</strong> have a height at least as large as \\(\\left\\lceil{\\frac{height}{maxFragmentDensityTexelSize_{height}}}\\right\\rceil\\)"
         }
       ],
+      "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [
+        {
+          "vuid": "VUID-VkFramebufferCreateInfo-renderPass-06502",
+          "text": " If <code>renderPass</code> was created with <a href=\"#renderpass-fragmentdensitymapoffsets\">fragment density map offsets</a> other than <span class=\"eq\">(0,0)</span>, each element of <code>pAttachments</code> <strong class=\"purple\">must</strong> have been created with a <code>flags</code> value including <code>VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM</code>."
+        }
+      ],
       "(VK_VERSION_1_1,VK_KHR_multiview)": [
         {
           "vuid": "VUID-VkFramebufferCreateInfo-renderPass-04536",
@@ -9538,7 +9578,67 @@
         },
         {
           "vuid": "VUID-VkSubpassEndInfo-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkSubpassFragmentDensityMapOffsetEndInfoQCOM\">VkSubpassFragmentDensityMapOffsetEndInfoQCOM</a>"
+        },
+        {
+          "vuid": "VUID-VkSubpassEndInfo-sType-unique",
+          "text": " The <code>sType</code> value of each struct in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be unique"
+        }
+      ]
+    },
+    "VkSubpassFragmentDensityMapOffsetEndInfoQCOM": {
+      "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_QCOM_fragment_density_map_offset)": [
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityMapOffsets-06503",
+          "text": " If the <a href=\"#features-fragmentDensityMapOffsets\"><code>fragmentDensityMapOffsets</code></a> feature is not enabled or fragment density map is not enabled in the render pass, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>0</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityMapAttachment-06504",
+          "text": " If <code>VkSubpassDescription</code>::<code>fragmentDensityMapAttachment</code> is not is not <code>VK_ATTACHMENT_UNUSED</code> and was not created with <code>VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM</code>, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>0</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pDepthStencilAttachment-06505",
+          "text": " If <code>VkSubpassDescription</code>::<code>pDepthStencilAttachment</code> is not is not <code>VK_ATTACHMENT_UNUSED</code> and was not created with <code>VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM</code>, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>0</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pInputAttachments-06506",
+          "text": " If any element of <code>VkSubpassDescription</code>::<code>pInputAttachments</code> is not is not <code>VK_ATTACHMENT_UNUSED</code> and was not created with <code>VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM</code>, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>0</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pColorAttachments-06507",
+          "text": " If any element of <code>VkSubpassDescription</code>::<code>pColorAttachments</code> is not is not <code>VK_ATTACHMENT_UNUSED</code> and was not created with <code>VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM</code>, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>0</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pResolveAttachments-06508",
+          "text": " If any element of <code>VkSubpassDescription</code>::<code>pResolveAttachments</code> is not is not <code>VK_ATTACHMENT_UNUSED</code> and was not created with <code>VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM</code>, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>0</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pPreserveAttachments-06509",
+          "text": " If any element of <code>VkSubpassDescription</code>::<code>pPreserveAttachments</code> is not is not <code>VK_ATTACHMENT_UNUSED</code> and was not created with <code>VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM</code>, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>0</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityOffsetCount-06510",
+          "text": " If <code>fragmentDensityOffsetCount</code> is not <code>0</code> and multiview is enabled for the render pass, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal the <code>layerCount</code> that was specified in creating the fragment density map attachment view."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityOffsetCount-06511",
+          "text": " If <code>fragmentDensityOffsetCount</code> is not <code>0</code> and multiview is not enabled for the render pass, <code>fragmentDensityOffsetCount</code> <strong class=\"purple\">must</strong> equal <code>1</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-x-06512",
+          "text": " The <code>x</code> component of each element of <code>pFragmentDensityOffsets</code> <strong class=\"purple\">must</strong> be an integer multiple of <code>fragmentDensityOffsetGranularity.width</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-y-06513",
+          "text": " The <code>y</code> component of each element of <code>pFragmentDensityOffsets</code> <strong class=\"purple\">must</strong> be an integer multiple of <code>fragmentDensityOffsetGranularity.height</code>."
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pFragmentDensityOffsets-parameter",
+          "text": " If <code>fragmentDensityOffsetCount</code> is not <code>0</code>, <code>pFragmentDensityOffsets</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>fragmentDensityOffsetCount</code> <a href=\"#VkOffset2D\">VkOffset2D</a> structures"
         }
       ]
     },
@@ -10433,10 +10533,6 @@
           "text": " If <code>renderPass</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the pipeline is being created with <a href=\"#pipeline-graphics-subsets-fragment-output\">fragment output interface state</a>, and <code>subpass</code> uses color attachments, <code>pColorBlendState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> structure"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06045",
-          "text": " If <code>renderPass</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and the pipeline is being created with <a href=\"#pipeline-graphics-subsets-fragment-output\">fragment output interface state</a>, <code>pColorBlendState-&gt;attachmentCount</code> <strong class=\"purple\">must</strong> be greater than the index of all color attachments that are not <code>VK_ATTACHMENT_UNUSED</code> for the <code>subpass</code> index in <code>renderPass</code>"
-        },
-        {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754",
           "text": " If the pipeline is being created with <a href=\"#pipeline-graphics-subsets-pre-rasterization\">pre-rasterization shader state</a>, the depth bias clamping feature is not enabled, no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> is <code>VK_DYNAMIC_STATE_DEPTH_BIAS</code>, and the <code>depthBiasEnable</code> member of <code>pRasterizationState</code> is <code>VK_TRUE</code>, the <code>depthBiasClamp</code> member of <code>pRasterizationState</code> <strong class=\"purple\">must</strong> be <code>0.0</code>"
         },
@@ -11017,11 +11113,19 @@
       ]
     },
     "VkPipelineRenderingCreateInfoKHR": {
-      "(VK_KHR_dynamic_rendering)": [
+      "(VK_KHR_dynamic_rendering)+!(VK_NV_linear_color_attachment)": [
         {
           "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-pColorAttachmentFormats-06064",
           "text": " If any element of <code>pColorAttachmentFormats</code> is not <code>VK_FORMAT_UNDEFINED</code>, it <strong class=\"purple\">must</strong> be a format with <a href=\"#potential-format-features\">potential format features</a> that include <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>"
-        },
+        }
+      ],
+      "(VK_KHR_dynamic_rendering)+(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-pColorAttachmentFormats-06495",
+          "text": " If any element of <code>pColorAttachmentFormats</code> is not <code>VK_FORMAT_UNDEFINED</code>, it <strong class=\"purple\">must</strong> be a format with <a href=\"#potential-format-features\">potential format features</a> that includes either <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        }
+      ],
+      "(VK_KHR_dynamic_rendering)": [
         {
           "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-depthAttachmentFormat-06065",
           "text": " If <code>depthAttachmentFormat</code> is not <code>VK_FORMAT_UNDEFINED</code>, it <strong class=\"purple\">must</strong> be a format with <a href=\"#potential-format-features\">potential format features</a> that include <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
@@ -14699,14 +14803,6 @@
           "text": " If <code>samples</code> is not <code>VK_SAMPLE_COUNT_1_BIT</code>, <code>usage</code> <strong class=\"purple\">must</strong> not contain <code>VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT</code>"
         },
         {
-          "vuid": "VUID-VkImageCreateInfo-usage-02559",
-          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT</code>, <code>extent.width</code> <strong class=\"purple\">must</strong> be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\right\\rceil\\)"
-        },
-        {
-          "vuid": "VUID-VkImageCreateInfo-usage-02560",
-          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT</code>, <code>extent.height</code> <strong class=\"purple\">must</strong> be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)"
-        },
-        {
           "vuid": "VUID-VkImageCreateInfo-flags-02565",
           "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT</code>, <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_OPTIMAL</code>"
         },
@@ -14729,6 +14825,26 @@
           "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT</code>, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_3D</code>"
         }
       ],
+      "(VK_EXT_fragment_density_map)+!(VK_QCOM_fragment_density_map_offset)": [
+        {
+          "vuid": "VUID-VkImageCreateInfo-usage-02559",
+          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT</code>, <code>extent.width</code> <strong class=\"purple\">must</strong> be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\right\\rceil\\)"
+        },
+        {
+          "vuid": "VUID-VkImageCreateInfo-usage-02560",
+          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT</code>, <code>extent.height</code> <strong class=\"purple\">must</strong> be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)"
+        }
+      ],
+      "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [
+        {
+          "vuid": "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06514",
+          "text": " If <a href=\"#features-fragmentDensityMapOffset\"><code>fragmentDensityMapOffset</code></a> is not enabled and <code>usage</code> includes <code>VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT</code>, <code>extent.width</code> <strong class=\"purple\">must</strong> be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\right\\rceil\\)"
+        },
+        {
+          "vuid": "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06515",
+          "text": " If <a href=\"#features-fragmentDensityMapOffset\"><code>fragmentDensityMapOffset</code></a> is not enabled and <code>usage</code> includes <code>VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT</code>, <code>extent.height</code> <strong class=\"purple\">must</strong> be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)"
+        }
+      ],
       "(VK_VERSION_1_1)": [
         {
           "vuid": "VUID-VkImageCreateInfo-flags-01890",
@@ -14938,7 +15054,7 @@
       "(VK_KHR_video_decode_queue)": [
         {
           "vuid": "VUID-VkImageCreateInfo-usage-04815",
-          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR</code>, <code>VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR</code>, <code>VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a valid <a href=\"#VkVideoProfilesKHR\">VkVideoProfilesKHR</a> structure which includes at least one <a href=\"#VkVideoProfileKHR\">VkVideoProfileKHR</a> with a decode codec-operation"
+          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR</code>, <code>VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a valid <a href=\"#VkVideoProfilesKHR\">VkVideoProfilesKHR</a> structure which includes at least one <a href=\"#VkVideoProfileKHR\">VkVideoProfileKHR</a> with a decode codec-operation"
         }
       ],
       "(VK_KHR_video_encode_queue)": [
@@ -15457,6 +15573,16 @@
           "text": " If <code>subresourceRange.layerCount</code> is not <code>VK_REMAINING_ARRAY_LAYERS</code>, <code>image</code> is a 3D image created with <code>VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT</code> set, and <code>viewType</code> is <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>, <code>subresourceRange.layerCount</code> <strong class=\"purple\">must</strong> be non-zero and <span class=\"eq\"><code>subresourceRange.baseArrayLayer</code> &#43; <code>subresourceRange.layerCount</code></span> <strong class=\"purple\">must</strong> be less than or equal to the depth computed from <code>baseMipLevel</code> and <code>extent.depth</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created, according to the formula defined in <a href=\"#resources-image-miplevel-sizing\">Image Miplevel Sizing</a>"
         }
       ],
+      "(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-VkImageViewCreateInfo-usage-06516",
+          "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, then the image view&#8217;s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>, if the image is created with <code>VK_IMAGE_TILING_LINEAR</code> and the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled"
+        },
+        {
+          "vuid": "VUID-VkImageViewCreateInfo-usage-06517",
+          "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>, then the image view&#8217;s <a href=\"#resources-image-view-format-features\">format features</a> must contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>, if the image is created with <code>VK_IMAGE_TILING_LINEAR</code> and the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled"
+        }
+      ],
       "(VK_EXT_fragment_density_map)": [
         {
           "vuid": "VUID-VkImageViewCreateInfo-image-02571",
@@ -19335,6 +19461,10 @@
           "text": " For each element <span class=\"eq\">i</span> where <code>pDescriptorWrites</code>[i].<code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code>, or <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code> the <code>imageView</code> member of any element of <code>pDescriptorWrites</code>[i] <strong class=\"purple\">must</strong> have been created on <code>device</code>"
         },
         {
+          "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06493",
+          "text": " For each element <span class=\"eq\">i</span> where <code>pDescriptorWrites</code>[i].<code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, or <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code>, <code>pDescriptorWrites</code>[i].<code>pImageInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pDescriptorWrites</code>[i].<code>descriptorCount</code> valid <code>VkDescriptorImageInfo</code> structures"
+        },
+        {
           "vuid": "VUID-vkUpdateDescriptorSets-device-parameter",
           "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDevice\">VkDevice</a> handle"
         },
@@ -19403,10 +19533,6 @@
           "text": " The sum of <code>dstArrayElement</code> and <code>descriptorCount</code> <strong class=\"purple\">must</strong> be less than or equal to the number of array elements in the descriptor set binding specified by <code>dstBinding</code>, and all applicable consecutive bindings, as described by <a href=\"#descriptorsets-updates-consecutive\">consecutive binding updates</a>"
         },
         {
-          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00322",
-          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, or <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code>, <code>pImageInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>descriptorCount</code> valid <code>VkDescriptorImageInfo</code> structures"
-        },
-        {
           "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02994",
           "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER</code> or <code>VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER</code>, each element of <code>pTexelBufferView</code> <strong class=\"purple\">must</strong> be either a valid <code>VkBufferView</code> handle or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
@@ -20073,6 +20199,10 @@
           "text": " <code>set</code> <strong class=\"purple\">must</strong> be the unique set number in the pipeline layout that uses a descriptor set layout that was created with <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR</code>"
         },
         {
+          "vuid": "VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-06494",
+          "text": " For each element <span class=\"eq\">i</span> where <code>pDescriptorWrites</code>[i].<code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, or <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code>, <code>pDescriptorWrites</code>[i].<code>pImageInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pDescriptorWrites</code>[i].<code>descriptorCount</code> valid <code>VkDescriptorImageInfo</code> structures"
+        },
+        {
           "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
         },
@@ -21986,7 +22116,7 @@
         },
         {
           "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-cmdpool",
-          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, or compute operations"
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, compute, decode, or encode operations"
         },
         {
           "vuid": "VUID-vkCmdResetQueryPool-renderpass",
@@ -22092,7 +22222,7 @@
         },
         {
           "vuid": "VUID-vkCmdBeginQuery-commandBuffer-cmdpool",
-          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, or compute operations"
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, compute, decode, or encode operations"
         },
         {
           "vuid": "VUID-vkCmdBeginQuery-commonparent",
@@ -22314,7 +22444,7 @@
         },
         {
           "vuid": "VUID-vkCmdEndQuery-commandBuffer-cmdpool",
-          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, or compute operations"
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, compute, decode, or encode operations"
         },
         {
           "vuid": "VUID-vkCmdEndQuery-commonparent",
@@ -22576,12 +22706,6 @@
           "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-02734",
           "text": " <a href=\"#vkCmdCopyQueryPoolResults\">vkCmdCopyQueryPoolResults</a> <strong class=\"purple\">must</strong> not be called if the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL</code>"
         }
-      ],
-      "(VK_KHR_video_queue)": [
-        {
-          "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-04812",
-          "text": " <a href=\"#vkCmdCopyQueryPoolResults\">vkCmdCopyQueryPoolResults</a> <strong class=\"purple\">must</strong> not be called if the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR</code> or <code>VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR</code>"
-        }
       ]
     },
     "vkCmdWriteTimestamp2KHR": {
@@ -22640,7 +22764,7 @@
         },
         {
           "vuid": "VUID-vkCmdWriteTimestamp2KHR-commandBuffer-cmdpool",
-          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support transfer, graphics, or compute operations"
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support transfer, graphics, compute, decode, or encode operations"
         },
         {
           "vuid": "VUID-vkCmdWriteTimestamp2KHR-commonparent",
@@ -22752,7 +22876,7 @@
         },
         {
           "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool",
-          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support transfer, graphics, or compute operations"
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support transfer, graphics, compute, decode, or encode operations"
         },
         {
           "vuid": "VUID-vkCmdWriteTimestamp-commonparent",
@@ -23100,6 +23224,14 @@
         }
       ]
     },
+    "VkQueueFamilyQueryResultStatusProperties2KHR": {
+      "(VK_KHR_video_queue)": [
+        {
+          "vuid": "VUID-VkQueueFamilyQueryResultStatusProperties2KHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR</code>"
+        }
+      ]
+    },
     "vkCmdClearColorImage": {
       "(VK_VERSION_1_1,VK_KHR_maintenance1)": [
         {
@@ -26413,6 +26545,12 @@
           "text": " <code>dstImageLayout</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR</code>, <code>VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_GENERAL</code>"
         }
       ],
+      "(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-vkCmdResolveImage-linearColorAttachment-06519",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, the <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        }
+      ],
       "(VK_EXT_fragment_density_map)": [
         {
           "vuid": "VUID-vkCmdResolveImage-dstImage-02546",
@@ -26845,6 +26983,12 @@
           "text": " <code>dstImageLayout</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR</code>, <code>VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_GENERAL</code>"
         }
       ],
+      "(VK_KHR_copy_commands2)+(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-VkResolveImageInfo2KHR-linearColorAttachment-06519",
+          "text": " If the <a href=\"#features-linearColorAttachment\"><code>linearColorAttachment</code></a> feature is enabled and the image is created with <code>VK_IMAGE_TILING_LINEAR</code>, the <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV</code>"
+        }
+      ],
       "(VK_KHR_copy_commands2)+(VK_EXT_fragment_density_map)": [
         {
           "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-02546",
@@ -38729,6 +38873,10 @@
     "vkGetPhysicalDeviceSurfaceCapabilitiesKHR": {
       "(VK_KHR_surface)": [
         {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-06523",
+          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-06211",
           "text": " <code>surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
         },
@@ -38753,6 +38901,10 @@
     "vkGetPhysicalDeviceSurfaceCapabilities2KHR": {
       "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [
         {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-06520",
+          "text": " <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-06210",
           "text": " <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
         },
@@ -38783,6 +38935,26 @@
           "text": " If the <code>pNext</code> chain includes a <a href=\"#VkSurfaceFullScreenExclusiveInfoEXT\">VkSurfaceFullScreenExclusiveInfoEXT</a> structure with its <code>fullScreenExclusive</code> member set to <code>VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT</code>, and <code>surface</code> was created using <a href=\"#vkCreateWin32SurfaceKHR\">vkCreateWin32SurfaceKHR</a>, a <a href=\"#VkSurfaceFullScreenExclusiveWin32InfoEXT\">VkSurfaceFullScreenExclusiveWin32InfoEXT</a> structure <strong class=\"purple\">must</strong> be included in the <code>pNext</code> chain"
         }
       ],
+      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface+VK_EXT_full_screen_exclusive)+(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pSurfaceInfo-06526",
+          "text": " When passed as the <code>pSurfaceInfo</code> parameter of <a href=\"#vkGetPhysicalDeviceSurfaceCapabilities2KHR\">vkGetPhysicalDeviceSurfaceCapabilities2KHR</a>, if the <code><a href=\"#VK_GOOGLE_surfaceless_query\">VK_GOOGLE_surfaceless_query</a></code> extension is enabled and the <code>pNext</code> chain of the <code>pSurfaceCapabilities</code> parameter includes <code>VkSurfaceProtectedCapabilitiesKHR</code>, then <code>surface</code> <strong class=\"purple\">can</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>. Otherwise, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
+          "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pSurfaceInfo-06527",
+          "text": " When passed as the <code>pSurfaceInfo</code> parameter of <a href=\"#vkGetPhysicalDeviceSurfaceFormats2KHR\">vkGetPhysicalDeviceSurfaceFormats2KHR</a>, if the <code><a href=\"#VK_GOOGLE_surfaceless_query\">VK_GOOGLE_surfaceless_query</a></code> extension is enabled, then <code>surface</code> <strong class=\"purple\">can</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>. Otherwise, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
+          "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pSurfaceInfo-06528",
+          "text": " When passed as the <code>pSurfaceInfo</code> parameter of <a href=\"#vkGetPhysicalDeviceSurfacePresentModes2EXT\">vkGetPhysicalDeviceSurfacePresentModes2EXT</a>, if the <code><a href=\"#VK_GOOGLE_surfaceless_query\">VK_GOOGLE_surfaceless_query</a></code> extension is enabled, then <code>surface</code> <strong class=\"purple\">can</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>. Otherwise, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        }
+      ],
+      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface+VK_EXT_full_screen_exclusive)+!(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-06529",
+          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        }
+      ],
       "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [
         {
           "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType",
@@ -38798,7 +38970,7 @@
         },
         {
           "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter",
-          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+          "text": " If <code>surface</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
         }
       ]
     },
@@ -38877,6 +39049,10 @@
     "vkGetPhysicalDeviceSurfaceCapabilities2EXT": {
       "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [
         {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-06523",
+          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-06211",
           "text": " <code>surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
         },
@@ -38915,18 +39091,34 @@
       ]
     },
     "vkGetPhysicalDeviceSurfaceFormatsKHR": {
-      "(VK_KHR_surface)": [
+      "(VK_KHR_surface)+(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06524",
+          "text": " If the <code><a href=\"#VK_GOOGLE_surfaceless_query\">VK_GOOGLE_surfaceless_query</a></code> extension is not enabled, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06525",
+          "text": " If <code>surface</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
+        }
+      ],
+      "(VK_KHR_surface)+!(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06523",
+          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06211",
           "text": " <code>surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
-        },
+        }
+      ],
+      "(VK_KHR_surface)": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter",
           "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> handle"
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter",
-          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+          "text": " If <code>surface</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter",
@@ -38938,16 +39130,32 @@
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent",
-          "text": " Both of <code>physicalDevice</code>, and <code>surface</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkInstance\">VkInstance</a>"
+          "text": " Both of <code>physicalDevice</code>, and <code>surface</code> that are valid handles of non-ignored parameters <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkInstance\">VkInstance</a>"
         }
       ]
     },
     "vkGetPhysicalDeviceSurfaceFormats2KHR": {
-      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [
+      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06521",
+          "text": " If the <code><a href=\"#VK_GOOGLE_surfaceless_query\">VK_GOOGLE_surfaceless_query</a></code> extension is not enabled, <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06522",
+          "text": " If <code>pSurfaceInfo-&gt;surface</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
+        }
+      ],
+      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+!(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06520",
+          "text": " <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06210",
           "text": " <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
-        },
+        }
+      ],
+      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter",
           "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> handle"
@@ -38979,18 +39187,34 @@
       ]
     },
     "vkGetPhysicalDeviceSurfacePresentModesKHR": {
-      "(VK_KHR_surface)": [
+      "(VK_KHR_surface)+(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06524",
+          "text": " If the <code><a href=\"#VK_GOOGLE_surfaceless_query\">VK_GOOGLE_surfaceless_query</a></code> extension is not enabled, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06525",
+          "text": " If <code>surface</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
+        }
+      ],
+      "(VK_KHR_surface)+!(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06523",
+          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06211",
           "text": " <code>surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
-        },
+        }
+      ],
+      "(VK_KHR_surface)": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter",
           "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> handle"
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter",
-          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+          "text": " If <code>surface</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter",
@@ -39002,16 +39226,32 @@
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent",
-          "text": " Both of <code>physicalDevice</code>, and <code>surface</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkInstance\">VkInstance</a>"
+          "text": " Both of <code>physicalDevice</code>, and <code>surface</code> that are valid handles of non-ignored parameters <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkInstance\">VkInstance</a>"
         }
       ]
     },
     "vkGetPhysicalDeviceSurfacePresentModes2EXT": {
-      "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)": [
+      "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)+(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06521",
+          "text": " If the <code><a href=\"#VK_GOOGLE_surfaceless_query\">VK_GOOGLE_surfaceless_query</a></code> extension is not enabled, <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06522",
+          "text": " If <code>pSurfaceInfo-&gt;surface</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
+        }
+      ],
+      "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)+!(VK_GOOGLE_surfaceless_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06520",
+          "text": " <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06210",
           "text": " <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
-        },
+        }
+      ],
+      "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter",
           "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> handle"
@@ -39141,6 +39381,10 @@
     "vkGetPhysicalDevicePresentRectanglesKHR": {
       "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [
         {
+          "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-06523",
+          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSurfaceKHR\">VkSurfaceKHR</a> handle"
+        },
+        {
           "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-06211",
           "text": " <code>surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
         },
@@ -43887,6 +44131,10 @@
     "VkVideoCodingControlInfoKHR": {
       "(VK_KHR_video_queue)": [
         {
+          "vuid": "VUID-VkVideoCodingControlInfoKHR-flags-06518",
+          "text": " The first command buffer submitted for a newly created video session <strong class=\"purple\">must</strong> set the <code>VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR</code> bit in <a href=\"#VkVideoCodingControlInfoKHR\">VkVideoCodingControlInfoKHR</a>::<code>flags</code> to reset the session device context before any video decode or encode operations are performed on the session."
+        },
+        {
           "vuid": "VUID-VkVideoCodingControlInfoKHR-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR</code>"
         },
@@ -44321,6 +44569,26 @@
       ]
     },
     "VkVideoEncodeRateControlInfoKHR": {
+      "(VK_KHR_video_encode_queue)+(VK_EXT_video_encode_h264)": [
+        {
+          "vuid": "VUID-VkVideoEncodeH264RateControlInfoEXT-chainrequirement",
+          "text": " <a href=\"#VkVideoEncodeH264RateControlInfoEXT\">VkVideoEncodeH264RateControlInfoEXT</a> <strong class=\"purple\">must</strong> be included in the <code>pNext</code> chain of <a href=\"#VkVideoEncodeRateControlInfoKHR\">VkVideoEncodeRateControlInfoKHR</a> if and only if <a href=\"#VkVideoEncodeRateControlInfoKHR\">VkVideoEncodeRateControlInfoKHR</a>::<code>rateControlMode</code> is not <code>VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR</code> and the bound video session was created with <a href=\"#VkVideoProfileKHR\">VkVideoProfileKHR</a>::<code>videoCodecOperation</code> set to <code>VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT</code>."
+        },
+        {
+          "vuid": "VUID-VkVideoEncodeH264RateControlInfoEXT-temporalLayerCount",
+          "text": " If <a href=\"#VkVideoEncodeRateControlInfoKHR\">VkVideoEncodeRateControlInfoKHR</a>::<code>layerCount</code> is greater than <code>1</code>, then <a href=\"#VkVideoEncodeH264RateControlInfoEXT\">VkVideoEncodeH264RateControlInfoEXT</a>::<code>temporalLayerCount</code> <strong class=\"purple\">must</strong> be equal to <code>layerCount</code>."
+        }
+      ],
+      "(VK_KHR_video_encode_queue)+(VK_EXT_video_encode_h265)": [
+        {
+          "vuid": "VUID-VkVideoEncodeH265RateControlInfoEXT-chainrequirement",
+          "text": " <a href=\"#VkVideoEncodeH265RateControlInfoEXT\">VkVideoEncodeH265RateControlInfoEXT</a> <strong class=\"purple\">must</strong> be included in the <code>pNext</code> chain of <a href=\"#VkVideoEncodeRateControlInfoKHR\">VkVideoEncodeRateControlInfoKHR</a> if and only if <a href=\"#VkVideoEncodeRateControlInfoKHR\">VkVideoEncodeRateControlInfoKHR</a>::<code>rateControlMode</code> is not <code>VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR</code> and the bound video session was created with <a href=\"#VkVideoProfileKHR\">VkVideoProfileKHR</a>::<code>videoCodecOperation</code> set to <code>VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT</code>."
+        },
+        {
+          "vuid": "VUID-VkVideoEncodeH265RateControlInfoEXT-subLayerCount",
+          "text": " If <a href=\"#VkVideoEncodeRateControlInfoKHR\">VkVideoEncodeRateControlInfoKHR</a>::<code>layerCount</code> is greater than <code>1</code>, then <a href=\"#VkVideoEncodeH265RateControlInfoEXT\">VkVideoEncodeH265RateControlInfoEXT</a>::<code>subLayerCount</code> <strong class=\"purple\">must</strong> be equal to <code>layerCount</code>."
+        }
+      ],
       "(VK_KHR_video_encode_queue)": [
         {
           "vuid": "VUID-VkVideoEncodeRateControlInfoKHR-sType-sType",
@@ -45265,13 +45533,21 @@
       ]
     },
     "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT": {
-      "(VK_EXT_fragment_density_map2)": [
+      "(VK_EXT_fragment_density_map)+(VK_EXT_fragment_density_map2)": [
         {
           "vuid": "VUID-VkPhysicalDeviceFragmentDensityMap2FeaturesEXT-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT</code>"
         }
       ]
     },
+    "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM": {
+      "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI": {
       "(VK_HUAWEI_invocation_mask)": [
         {
@@ -45864,6 +46140,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceLinearColorAttachmentFeaturesNV": {
+      "(VK_NV_linear_color_attachment)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceLinearColorAttachmentFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV</code>"
+        }
+      ]
+    },
     "VkPhysicalDevicePushDescriptorPropertiesKHR": {
       "(VK_KHR_push_descriptor)": [
         {
@@ -46033,13 +46317,21 @@
       ]
     },
     "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT": {
-      "(VK_EXT_fragment_density_map2)": [
+      "(VK_EXT_fragment_density_map)+(VK_EXT_fragment_density_map2)": [
         {
           "vuid": "VUID-VkPhysicalDeviceFragmentDensityMap2PropertiesEXT-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT</code>"
         }
       ]
     },
+    "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM": {
+      "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceShaderCorePropertiesAMD": {
       "(VK_AMD_shader_core_properties)": [
         {
@@ -47997,6 +48289,10 @@
           "text": " The product of <code>x</code> size, <code>y</code> size, and <code>z</code> size in <code>LocalSize</code> or <code>LocalSizeId</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxComputeWorkGroupInvocations</code>"
         },
         {
+          "vuid": "VUID-RuntimeSpirv-Workgroup-06530",
+          "text": " The sum of size in bytes for variables and <a href=\"#limits-maxComputeSharedMemorySize\">padding</a> in the <code>Workgroup</code> storage class in the <code>GLCompute</code> {ExecutionModel} <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-maxComputeSharedMemorySize\"><code>maxComputeSharedMemorySize</code></a>"
+        },
+        {
           "vuid": "VUID-RuntimeSpirv-OpImage-06376",
           "text": " If an <code>OpImage*Gather</code> operation has an image operand of <code>Offset</code>, <code>ConstOffset</code>, or <code>ConstOffsets</code> the offset value <strong class=\"purple\">must</strong> be greater than or equal to <a href=\"#limits-minTexelGatherOffset\">minTexelGatherOffset</a>"
         },
@@ -48592,19 +48888,11 @@
         },
         {
           "vuid": "VUID-VkCuLaunchInfoNVX-pParams-parameter",
-          "text": " <code>pParams</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>paramCount</code> bytes"
+          "text": " If <code>paramCount</code> is not <code>0</code>, <code>pParams</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>paramCount</code> bytes"
         },
         {
           "vuid": "VUID-VkCuLaunchInfoNVX-pExtras-parameter",
-          "text": " <code>pExtras</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>extraCount</code> bytes"
-        },
-        {
-          "vuid": "VUID-VkCuLaunchInfoNVX-paramCount-arraylength",
-          "text": " <code>paramCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
-        },
-        {
-          "vuid": "VUID-VkCuLaunchInfoNVX-extraCount-arraylength",
-          "text": " <code>extraCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+          "text": " If <code>extraCount</code> is not <code>0</code>, <code>pExtras</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>extraCount</code> bytes"
         }
       ]
     }
diff --git a/registry/vk.xml b/registry/vk.xml
index 56b4890..6a8d05e 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> 202</type>
+#define <name>VK_HEADER_VERSION</name> 203</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>
 
@@ -2922,7 +2922,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkPhysicalDeviceSurfaceInfo2KHR">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true">const <type>void</type>* <name>pNext</name></member>
-            <member><type>VkSurfaceKHR</type> <name>surface</name></member>
+            <member optional="true"><type>VkSurfaceKHR</type> <name>surface</name></member>
         </type>
         <type category="struct" name="VkSurfaceCapabilities2KHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
@@ -4304,26 +4304,42 @@ typedef void <name>CAMetalLayer</name>;
             <member optional="true"><type>void</type>*                            <name>pNext</name></member>
             <member><type>VkBool32</type>                         <name>fragmentDensityMapDeferred</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*            <name>pNext</name></member>
+            <member><type>VkBool32</type>                         <name>fragmentDensityMapOffset</name></member>
+        </type>
         <type category="struct" name="VkPhysicalDeviceFragmentDensityMapPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                            <name>pNext</name></member>
             <member limittype="min"><type>VkExtent2D</type>                       <name>minFragmentDensityTexelSize</name></member>
             <member limittype="max"><type>VkExtent2D</type>                       <name>maxFragmentDensityTexelSize</name></member>
-            <member limittype="bitmask"><type>VkBool32</type>                         <name>fragmentDensityInvocations</name></member>
+            <member limittype="bitmask"><type>VkBool32</type>                     <name>fragmentDensityInvocations</name></member>
         </type>
         <type category="struct" name="VkPhysicalDeviceFragmentDensityMap2PropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                          <name>pNext</name></member>
-            <member limittype="noauto"><type>VkBool32</type>                       <name>subsampledLoads</name></member>
-            <member limittype="noauto"><type>VkBool32</type>                       <name>subsampledCoarseReconstructionEarlyAccess</name></member>
+            <member limittype="noauto"><type>VkBool32</type>                    <name>subsampledLoads</name></member>
+            <member limittype="noauto"><type>VkBool32</type>                    <name>subsampledCoarseReconstructionEarlyAccess</name></member>
             <member limittype="max"><type>uint32_t</type>                       <name>maxSubsampledArrayLayers</name></member>
             <member limittype="max"><type>uint32_t</type>                       <name>maxDescriptorSetSubsampledSamplers</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*                            <name>pNext</name></member>
+            <member limittype="max"><type>VkExtent2D</type>                       <name>fragmentDensityOffsetGranularity</name></member>
+        </type>
         <type category="struct" name="VkRenderPassFragmentDensityMapCreateInfoEXT" structextends="VkRenderPassCreateInfo,VkRenderPassCreateInfo2">
             <member values="VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true">const <type>void</type>*                      <name>pNext</name></member>
             <member><type>VkAttachmentReference</type>            <name>fragmentDensityMapAttachment</name></member>
         </type>
+        <type category="struct" name="VkSubpassFragmentDensityMapOffsetEndInfoQCOM" structextends="VkSubpassEndInfo">
+            <member values="VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true">const <type>void</type>*                        <name>pNext</name></member>
+            <member optional="true"><type>uint32_t</type>                           <name>fragmentDensityOffsetCount</name></member>
+            <member len="fragmentDensityOffsetCount">const <type>VkOffset2D</type>* <name>pFragmentDensityOffsets</name></member>
+        </type>
         <type category="struct" name="VkPhysicalDeviceScalarBlockLayoutFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                               <name>pNext</name></member>
@@ -5616,6 +5632,11 @@ typedef void <name>CAMetalLayer</name>;
             <member optional="true"><type>void</type>*                              <name>pNext</name></member>
             <member><type>VkVideoCodecOperationFlagsKHR</type>      <name>videoCodecOperations</name></member>
         </type>
+        <type category="struct" name="VkQueueFamilyQueryResultStatusProperties2KHR" structextends="VkQueueFamilyProperties2">
+            <member values="VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR"><type>VkStructureType</type><name>sType</name></member>
+            <member optional="true"><type>void</type>*                              <name>pNext</name></member>
+            <member><type>VkBool32</type>      <name>supported</name></member>
+        </type>
         <type category="struct" name="VkVideoProfilesKHR" structextends="VkFormatProperties2,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferCreateInfo">
             <member values="VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR"><type>VkStructureType</type><name>sType</name></member>
             <member optional="true"><type>void</type>*                              <name>pNext</name></member>
@@ -6013,6 +6034,7 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>uint32_t</type>                                        <name>idrPeriod</name></member>
             <member><type>uint32_t</type>                                        <name>consecutiveBFrameCount</name></member>
             <member><type>VkVideoEncodeH264RateControlStructureFlagBitsEXT</type> <name>rateControlStructure</name></member>
+            <member><type>uint8_t</type>                                         <name>temporalLayerCount</name></member>
         </type>
         <type category="struct" name="VkVideoEncodeH264QpEXT">
             <member noautovalidity="true"><type>int32_t</type> <name>qpI</name></member>
@@ -6117,6 +6139,7 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>uint32_t</type>                                        <name>idrPeriod</name></member>
             <member><type>uint32_t</type>                                        <name>consecutiveBFrameCount</name></member>
             <member><type>VkVideoEncodeH265RateControlStructureFlagBitsEXT</type> <name>rateControlStructure</name></member>
+            <member><type>uint8_t</type>                                         <name>subLayerCount</name></member>
         </type>
         <type category="struct" name="VkVideoEncodeH265QpEXT">
             <member noautovalidity="true"><type>int32_t</type> <name>qpI</name></member>
@@ -6218,9 +6241,9 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>uint32_t</type>               <name>blockDimY</name></member>
             <member><type>uint32_t</type>               <name>blockDimZ</name></member>
             <member><type>uint32_t</type>               <name>sharedMemBytes</name></member>
-            <member><type>size_t</type>                 <name>paramCount</name></member>
+            <member optional="true"><type>size_t</type>                 <name>paramCount</name></member>
             <member len="paramCount">const <type>void</type>* const *    <name>pParams</name></member>
-            <member><type>size_t</type>                 <name>extraCount</name></member>
+            <member optional="true"><type>size_t</type>                 <name>extraCount</name></member>
             <member len="extraCount">const <type>void</type>* const *    <name>pExtras</name></member>
         </type>
         <type category="struct" name="VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
@@ -6550,6 +6573,11 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkBool32</type>                         <name>rasterizationOrderDepthAttachmentAccess</name></member>
             <member><type>VkBool32</type>                         <name>rasterizationOrderStencilAttachmentAccess</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceLinearColorAttachmentFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true" noautovalidity="true"><type>void</type>*     <name>pNext</name></member>
+            <member><type>VkBool32</type>                                        <name>linearColorAttachment</name></member>
+        </type>
     </types>
     <comment>Vulkan enumerant (token) definitions</comment>
 
@@ -8120,7 +8148,6 @@ typedef void <name>CAMetalLayer</name>;
         <enum bitpos="8"      name="VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT"/>
         <enum bitpos="9"      name="VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT"/>
         <enum bitpos="10"     name="VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT"/>
-        <enum bitpos="11"     name="VK_VIDEO_ENCODE_H264_CAPABILITY_OPTIONAL_RC_EXTENSION_STRUCT_BIT_EXT"/>
     </enums>
     <enums name="VkVideoEncodeH264InputModeFlagBitsEXT" type="bitmask">
         <enum bitpos="0"      name="VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT"/>
@@ -9135,14 +9162,14 @@ typedef void <name>CAMetalLayer</name>;
             <param optional="true"><type>uint32_t</type> <name>imageMemoryBarrierCount</name></param>
             <param len="imageMemoryBarrierCount">const <type>VkImageMemoryBarrier</type>* <name>pImageMemoryBarriers</name></param>
         </command>
-        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="graphics,compute,decode,encode" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdBeginQuery</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>VkQueryPool</type> <name>queryPool</name></param>
             <param><type>uint32_t</type> <name>query</name></param>
             <param optional="true"><type>VkQueryControlFlags</type> <name>flags</name></param>
         </command>
-        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="graphics,compute,decode,encode" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdEndQuery</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>VkQueryPool</type> <name>queryPool</name></param>
@@ -9157,14 +9184,14 @@ typedef void <name>CAMetalLayer</name>;
             <proto><type>void</type> <name>vkCmdEndConditionalRenderingEXT</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
         </command>
-        <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
+        <command queues="graphics,compute,decode,encode" renderpass="outside" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdResetQueryPool</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>VkQueryPool</type> <name>queryPool</name></param>
             <param><type>uint32_t</type> <name>firstQuery</name></param>
             <param><type>uint32_t</type> <name>queryCount</name></param>
         </command>
-        <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="transfer,graphics,compute,decode,encode" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdWriteTimestamp</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>VkPipelineStageFlagBits</type> <name>pipelineStage</name></param>
@@ -9297,14 +9324,14 @@ typedef void <name>CAMetalLayer</name>;
         <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
             <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfaceFormatsKHR</name></proto>
             <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
-            <param><type>VkSurfaceKHR</type> <name>surface</name></param>
+            <param optional="true"><type>VkSurfaceKHR</type> <name>surface</name></param>
             <param optional="false,true"><type>uint32_t</type>* <name>pSurfaceFormatCount</name></param>
             <param optional="true" len="pSurfaceFormatCount"><type>VkSurfaceFormatKHR</type>* <name>pSurfaceFormats</name></param>
         </command>
         <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
             <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfacePresentModesKHR</name></proto>
             <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
-            <param><type>VkSurfaceKHR</type> <name>surface</name></param>
+            <param optional="true"><type>VkSurfaceKHR</type> <name>surface</name></param>
             <param optional="false,true"><type>uint32_t</type>* <name>pPresentModeCount</name></param>
             <param optional="true" len="pPresentModeCount"><type>VkPresentModeKHR</type>* <name>pPresentModes</name></param>
         </command>
@@ -11122,7 +11149,7 @@ typedef void <name>CAMetalLayer</name>;
             <param len="submitCount">const <type>VkSubmitInfo2KHR</type>*           <name>pSubmits</name></param>
             <param optional="true" externsync="true"><type>VkFence</type>           <name>fence</name></param>
         </command>
-        <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="transfer,graphics,compute,decode,encode" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdWriteTimestamp2KHR</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type>                   <name>commandBuffer</name></param>
             <param optional="true"><type>VkPipelineStageFlags2KHR</type>            <name>stage</name></param>
@@ -12683,6 +12710,7 @@ typedef void <name>CAMetalLayer</name>;
                 <enum offset="13" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="14" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="15" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
+                <enum offset="16" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
 
                 <enum offset="0"  extends="VkObjectType"                name="VK_OBJECT_TYPE_VIDEO_SESSION_KHR"             comment="VkVideoSessionKHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1"  extends="VkObjectType"                name="VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR"  comment="VkVideoSessionParametersKHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -12710,6 +12738,7 @@ typedef void <name>CAMetalLayer</name>;
                 <type name="VkVideoCodingQualityPresetFlagBitsKHR"/>
                 <type name="VkVideoCodingQualityPresetFlagsKHR"/>
 
+                <type name="VkQueueFamilyQueryResultStatusProperties2KHR"/>
                 <type name="VkQueryResultStatusKHR"/>
 
                 <type name="VkVideoQueueFamilyProperties2KHR"/>
@@ -12913,7 +12942,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="2"                                                 name="VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION"/>
+                <enum value="3"                                                 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"/>
@@ -12955,7 +12984,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_video_encode_h265" number="40" type="device" requires="VK_KHR_video_encode_queue" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="2"                                              name="VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION"/>
+                <enum value="3"                                              name="VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_video_encode_h265&quot;"           name="VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -17556,11 +17585,17 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_ARM_extension_425&quot;"          name="VK_ARM_EXTENSION_425_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_QCOM_extension_426" number="426" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
+        <extension name="VK_QCOM_fragment_density_map_offset" number="426" type="device" requires="VK_KHR_get_physical_device_properties2,VK_EXT_fragment_density_map" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_QCOM_EXTENSION_426_SPEC_VERSION"/>
-                <enum value="&quot;VK_QCOM_extension_426&quot;"         name="VK_QCOM_EXTENSION_426_EXTENSION_NAME"/>
-                <enum bitpos="15" extends="VkImageCreateFlagBits"       name="VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM"/>
+                <enum value="1"                                               name="VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION"/>
+                <enum value="&quot;VK_QCOM_fragment_density_map_offset&quot;" name="VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME"/>
+                <enum offset="0"  extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM"/>
+                <enum offset="1"  extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM"/>
+                <enum offset="2"  extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM"/>
+                <enum bitpos="15" extends="VkImageCreateFlagBits"             name="VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM"/>
+                <type name="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM"/>
+                <type name="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM"/>
+                <type name="VkSubpassFragmentDensityMapOffsetEndInfoQCOM"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_427" number="427" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">
@@ -17587,10 +17622,15 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_NV_extension_430&quot;"           name="VK_NV_EXTENSION_430_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_431" number="431" author="NV" contact="Sourav Parmar @souravpNV" supported="disabled">
+        <extension name="VK_NV_linear_color_attachment" number="431" type="device" author="NVIDIA" contact="sourav parmar @souravpNV" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_431_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_431&quot;"           name="VK_NV_EXTENSION_431_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_linear_color_attachment&quot;"     name="VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV"/>
+                <type                                                       name="VkPhysicalDeviceLinearColorAttachmentFeaturesNV"/>
+            </require>
+            <require extension="VK_KHR_format_feature_flags2">
+                <enum bitpos="38" extends="VkFormatFeatureFlagBits2KHR"     name="VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" comment="Format support linear image as render target, it cannot be mixed with non linear attachment"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_432" number="432" author="NV" contact="Sourav Parmar @souravpNV" supported="disabled">
@@ -17605,10 +17645,10 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_NV_extension_433&quot;"           name="VK_NV_EXTENSION_433_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_extension_434" number="434" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
+        <extension name="VK_GOOGLE_surfaceless_query" number="434" type="instance" requires="VK_KHR_surface" author="GOOGLE" contact="Shahbaz Youssefi @syoussefi" specialuse="glemulation" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_EXT_EXTENSION_434_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_434&quot;"          name="VK_EXT_EXTENSION_434_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION"/>
+                <enum value="&quot;VK_GOOGLE_surfaceless_query&quot;"   name="VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME"/>
             </require>
         </extension>
         <extension name="VK_KHR_extension_435" number="435" author="KHR" contact="Alan Baker @alan-baker" supported="disabled">
@@ -17641,6 +17681,88 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_SEC_extension_439&quot;"          name="VK_SEC_EXTENSION_439_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_QCOM_extension_440" number="440" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
+            <require>
+                <enum value="0"                                                 name="VK_QCOM_EXTENSION_440_SPEC_VERSION"/>
+                <enum value="&quot;VK_QCOM_extension_440&quot;"                 name="VK_QCOM_EXTENSION_440_EXTENSION_NAME"/>
+                <enum bitpos="7" extends="VkQueueFlagBits"                      name="VK_QUEUE_RESERVED_7_BIT_QCOM"/>
+                <enum bitpos="1" extends="VkDeviceQueueCreateFlagBits"          name="VK_DEVICE_QUEUE_CREATE_RESERVED_1_BIT_QCOM"/>
+            </require>
+        </extension>
+        <extension name="VK_QCOM_extension_441" number="441" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_QCOM_EXTENSION_441_SPEC_VERSION"/>
+                <enum value="&quot;VK_QCOM_extension_441&quot;"             name="VK_QCOM_EXTENSION_441_EXTENSION_NAME"/>
+                <enum bitpos="4" extends="VkSamplerCreateFlagBits"          name="VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM"/>
+                <enum bitpos="20" extends="VkImageUsageFlagBits"            name="VK_IMAGE_USAGE_RESERVED_20_BIT_QCOM"/>
+                <enum bitpos="21" extends="VkImageUsageFlagBits"            name="VK_IMAGE_USAGE_RESERVED_21_BIT_QCOM"/>
+                <enum bitpos="34" extends="VkFormatFeatureFlagBits2KHR"     name="VK_FORMAT_FEATURE_2_RESERVED_34_BIT_QCOM"/>
+                <enum bitpos="35" extends="VkFormatFeatureFlagBits2KHR"     name="VK_FORMAT_FEATURE_2_RESERVED_35_BIT_QCOM"/>
+                <enum bitpos="36" extends="VkFormatFeatureFlagBits2KHR"     name="VK_FORMAT_FEATURE_2_RESERVED_36_BIT_QCOM"/>
+                <enum bitpos="37" extends="VkFormatFeatureFlagBits2KHR"     name="VK_FORMAT_FEATURE_2_RESERVED_37_BIT_QCOM"/>
+            </require>
+        </extension>
+        <extension name="VK_COREAVI_extension_442" number="442" author="COREAVI" contact="Aidan Fabius @afabius" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_COREAVI_EXTENSION_442_SPEC_VERSION"/>
+                <enum value="&quot;VK_COREAVI_extension_442&quot;"          name="VK_COREAVI_EXTENSION_442_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_COREAVI_extension_443" number="443" author="COREAVI" contact="Aidan Fabius @afabius" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_COREAVI_EXTENSION_443_SPEC_VERSION"/>
+                <enum value="&quot;VK_COREAVI_extension_443&quot;"          name="VK_COREAVI_EXTENSION_443_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_COREAVI_extension_444" number="444" author="COREAVI" contact="Aidan Fabius @afabius" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_COREAVI_EXTENSION_444_SPEC_VERSION"/>
+                <enum value="&quot;VK_COREAVI_extension_444&quot;"          name="VK_COREAVI_EXTENSION_444_EXTENSION_NAME"/>
+                <enum extends="VkCommandPoolResetFlagBits" bitpos="1"       name="VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI"/>
+            </require>
+        </extension>
+        <extension name="VK_COREAVI_extension_445" number="445" author="COREAVI" contact="Aidan Fabius @afabius" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_COREAVI_EXTENSION_445_SPEC_VERSION"/>
+                <enum value="&quot;VK_COREAVI_extension_445&quot;"          name="VK_COREAVI_EXTENSION_445_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_COREAVI_extension_446" number="446" author="COREAVI" contact="Aidan Fabius @afabius" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_COREAVI_EXTENSION_446_SPEC_VERSION"/>
+                <enum value="&quot;VK_COREAVI_extension_446&quot;"          name="VK_COREAVI_EXTENSION_446_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_COREAVI_extension_447" number="447" author="COREAVI" contact="Aidan Fabius @afabius" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_COREAVI_EXTENSION_447_SPEC_VERSION"/>
+                <enum value="&quot;VK_COREAVI_extension_447&quot;"          name="VK_COREAVI_EXTENSION_447_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_SEC_extension_448" number="448" author="SEC" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_SEC_EXTENSION_448_SPEC_VERSION"/>
+                <enum value="&quot;VK_SEC_extension_448&quot;"          name="VK_SEC_EXTENSION_448_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_SEC_extension_449" number="449" author="SEC" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_SEC_EXTENSION_449_SPEC_VERSION"/>
+                <enum value="&quot;VK_SEC_extension_449&quot;"          name="VK_SEC_EXTENSION_449_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_SEC_extension_450" number="450" author="SEC" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_SEC_EXTENSION_450_SPEC_VERSION"/>
+                <enum value="&quot;VK_SEC_extension_450&quot;"          name="VK_SEC_EXTENSION_450_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_SEC_extension_451" number="451" author="SEC" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_SEC_EXTENSION_451_SPEC_VERSION"/>
+                <enum value="&quot;VK_SEC_extension_451&quot;"          name="VK_SEC_EXTENSION_451_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
     <formats>
         <format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">
@@ -18417,13 +18539,13 @@ typedef void <name>CAMetalLayer</name>;
             <component name="B" bits="compressed" numericFormat="SRGB"/>
             <component name="A" bits="compressed" numericFormat="SRGB"/>
         </format>
-        <format name="VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK" class="ETC2_EAC_RGBA" blockSize="8" texelsPerBlock="16" blockExtent="4,4,1" compressed="ETC2">
+        <format name="VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK" class="ETC2_EAC_RGBA" blockSize="16" texelsPerBlock="16" blockExtent="4,4,1" compressed="ETC2">
             <component name="R" bits="compressed" numericFormat="UNORM"/>
             <component name="G" bits="compressed" numericFormat="UNORM"/>
             <component name="B" bits="compressed" numericFormat="UNORM"/>
             <component name="A" bits="compressed" numericFormat="UNORM"/>
         </format>
-        <format name="VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK" class="ETC2_EAC_RGBA" blockSize="8" texelsPerBlock="16" blockExtent="4,4,1" compressed="ETC2">
+        <format name="VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK" class="ETC2_EAC_RGBA" blockSize="16" texelsPerBlock="16" blockExtent="4,4,1" compressed="ETC2">
             <component name="R" bits="compressed" numericFormat="SRGB"/>
             <component name="G" bits="compressed" numericFormat="SRGB"/>
             <component name="B" bits="compressed" numericFormat="SRGB"/>