diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index f788f79..c3c9948 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -34,9 +34,6 @@ std::set<size_t> determineSingularParams( size_t                           retur
 std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices );
 std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" );
 std::string generateCArraySizes( std::vector<std::string> const & sizes );
-std::string generateCommandName( std::string const &           vulkanCommandName,
-                                 std::string const &           argumentType,
-                                 std::set<std::string> const & tags );
 std::pair<std::string, std::string>
             generateEnumSuffixes( std::string const & name, bool bitmask, std::set<std::string> const & tags );
 std::string generateEnumValueName( std::string const &           enumName,
@@ -225,53 +222,6 @@ std::string generateCArraySizes( std::vector<std::string> const & sizes )
   return arraySizes;
 }
 
-std::string generateCommandName( std::string const &           vulkanCommandName,
-                                 std::string const &           argumentType,
-                                 std::set<std::string> const & tags )
-{
-  std::string commandName( startLowerCase( stripPrefix( vulkanCommandName, "vk" ) ) );
-  if ( !argumentType.empty() )
-  {
-    std::string searchName  = stripPrefix( argumentType, "Vk" );
-    std::string argumentTag = findTag( tags, argumentType );
-    if ( !argumentTag.empty() )
-    {
-      searchName = stripPostfix( searchName, argumentTag );
-    }
-    size_t pos = commandName.find( searchName );
-    if ( ( pos == std::string::npos ) && isupper( searchName[0] ) )
-    {
-      searchName[0] = static_cast<char>( tolower( searchName[0] ) );
-      pos           = commandName.find( searchName );
-    }
-    if ( pos != std::string::npos )
-    {
-      size_t len = searchName.length();
-      if ( commandName.find( searchName + "s" ) == pos )
-      {
-        // filter out any plural of the searchName as well!
-        ++len;
-      }
-      commandName.erase( pos, len );
-    }
-    else if ( ( searchName == "commandBuffer" ) && beginsWith( commandName, "cmd" ) )
-    {
-      commandName.erase( 0, 3 );
-      pos = 0;
-    }
-    if ( ( pos == 0 ) && isupper( commandName[0] ) )
-    {
-      commandName[0] = static_cast<char>( tolower( commandName[0] ) );
-    }
-    std::string commandTag = findTag( tags, commandName );
-    if ( !argumentTag.empty() && ( argumentTag == commandTag ) )
-    {
-      commandName = stripPostfix( commandName, argumentTag );
-    }
-  }
-  return commandName;
-}
-
 std::pair<std::string, std::string>
   generateEnumSuffixes( std::string const & name, bool bitmask, std::set<std::string> const & tags )
 {
@@ -901,7 +851,7 @@ void VulkanHppGenerator::appendDestroyCommand( std::string &       str,
 ) const
 {
   // special handling for destroy functions, filter out alias functions
-  std::string commandName = generateCommandName( name, commandData.params[0].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, 1, m_tags );
   if ( commandData.alias.empty() &&
        ( ( ( name.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
          ( name.substr( 2, 4 ) == "Free" ) || ( name == "vkReleasePerformanceConfigurationINTEL" ) ) )
@@ -1235,7 +1185,7 @@ ${i}  }
 )#";
 
   // add some error checks if multiple vectors need to have the same size
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   for ( std::map<size_t, size_t>::const_iterator it0 = vectorParamIndices.begin(); it0 != vectorParamIndices.end();
         ++it0 )
   {
@@ -1272,7 +1222,7 @@ void VulkanHppGenerator::appendFunctionBodyEnhancedReturnResultValue( std::strin
   std::string returnVectorName = ( returnParamIndex != INVALID_INDEX )
                                    ? stripPostfix( stripPrefix( commandData.params[returnParamIndex].name, "p" ), "s" )
                                    : "";
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName      = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
 
   assert( commandData.returnType != "void" );
 
@@ -1547,8 +1497,7 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
           assert( commandIt != m_commands.end() );
 
           std::string commandString;
-          std::string commandName =
-            generateCommandName( commandIt->first, commandIt->second.params[0].type.type, m_tags );
+          std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, 1, m_tags );
           commands += "\n";
           commands += generateCommand( commandIt->first, commandIt->second, 1, false );
           appendDestroyCommand( commands,
@@ -2816,9 +2765,8 @@ std::string VulkanHppGenerator::constructCommandBoolGetValue( std::string const
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName =
-    generateCommandName( name, initialSkipCount ? commandData.params[initialSkipCount - 1].type.type : "", m_tags );
-  std::string returnType = stripPostfix( commandData.params[nonConstPointerIndex].type.compose(), "*" );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
+  std::string returnType  = stripPostfix( commandData.params[nonConstPointerIndex].type.compose(), "*" );
   assert( !beginsWith( returnType, "Vk" ) );
 
   if ( definition )
@@ -2875,7 +2823,7 @@ std::string VulkanHppGenerator::constructCommandResult( std::string const &
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnType  = ( 1 < commandData.successCodes.size() ) ? "Result" : "typename ResultValueType<void>::type";
 
@@ -2936,9 +2884,8 @@ std::string VulkanHppGenerator::constructCommandResultEnumerate( std::string con
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocator, false, true );
-  std::string commandName =
-    generateCommandName( name, initialSkipCount ? commandData.params[initialSkipCount - 1].type.type : "", m_tags );
-  std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
+  std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string vectorElementType = ( commandData.params[vectorParamIndices.first].type.type == "void" )
                                     ? "uint8_t"
                                     : stripPrefix( commandData.params[vectorParamIndices.first].type.type, "Vk" );
@@ -3037,7 +2984,7 @@ std::string
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocator, true, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   assert( beginsWith( commandData.params[vectorParamIndex.first].type.type, "Vk" ) );
   std::string vectorElementType =
@@ -3152,7 +3099,7 @@ std::string
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocators, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string templateTypeFirst  = stripPrefix( commandData.params[firstVectorParamIt->first].type.type, "Vk" );
   std::string templateTypeSecond = stripPrefix( commandData.params[secondVectorParamIt->first].type.type, "Vk" );
@@ -3261,7 +3208,7 @@ std::string VulkanHppGenerator::constructCommandResultEnumerateTwoVectorsDepreca
 
   std::string argumentList = constructFunctionHeaderArgumentsEnhanced(
     commandData, returnParamIndex, returnParamIndex, vectorParamIndices, !definition, withAllocators );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnType  = determineEnhancedReturnType( commandData, returnParamIndex, false );
   std::string templateType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
@@ -3337,7 +3284,7 @@ std::string VulkanHppGenerator::constructCommandResultGetChain( std::string cons
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   assert( beginsWith( commandData.params[nonConstPointerIndex].type.type, "Vk" ) );
   std::string returnType =
@@ -3393,9 +3340,8 @@ std::string VulkanHppGenerator::constructCommandResultGetHandleUnique( std::stri
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName =
-    generateCommandName( name, initialSkipCount ? commandData.params[initialSkipCount - 1].type.type : "", m_tags );
-  std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
+  std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnBaseType = commandData.params[nonConstPointerIndex].type.compose();
   assert( endsWith( returnBaseType, "*" ) );
   returnBaseType.pop_back();
@@ -3493,7 +3439,7 @@ std::string VulkanHppGenerator::constructCommandResultGetTwoValues(
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string firstType   = commandData.params[nonConstPointerParamIndices[0]].type.compose();
   assert( endsWith( firstType, "*" ) );
   firstType.pop_back();
@@ -3570,7 +3516,7 @@ std::string
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
   std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT";
 
@@ -3629,9 +3575,8 @@ std::string VulkanHppGenerator::constructCommandResultGetValue( std::string cons
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName =
-    generateCommandName( name, initialSkipCount ? commandData.params[initialSkipCount - 1].type.type : "", m_tags );
-  std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
+  std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnBaseType = commandData.params[nonConstPointerIndex].type.compose();
   assert( endsWith( returnBaseType, "*" ) );
   returnBaseType.pop_back();
@@ -3694,7 +3639,7 @@ std::string
 
   std::string argumentList = constructFunctionHeaderArgumentsEnhanced(
     commandData, returnParamIndex, INVALID_INDEX, vectorParamIndices, !definition, false );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
 
   assert( !beginsWith( commandData.params[returnParamIndex].type.type, "Vk" ) );
@@ -3759,7 +3704,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVector( std::string con
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnType  = constructReturnType( commandData, "std::vector<T,Allocator>" );
 
@@ -3825,7 +3770,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVector( std::string con
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, withAllocator, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
 
   assert( beginsWith( commandData.params[returnParamIndex].type.type, "Vk" ) );
@@ -3912,7 +3857,7 @@ std::string
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, withAllocator, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnType  = constructReturnType( commandData, "std::vector<T,Allocator>" );
 
@@ -3998,7 +3943,7 @@ std::string
 
   std::string argumentList = constructFunctionHeaderArgumentsEnhanced(
     commandData, INVALID_INDEX, returnParamIndex, vectorParamIndices, !definition, false );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnType  = constructReturnType( commandData, "void" );
 
@@ -4063,7 +4008,7 @@ std::string
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocator, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string handleType  = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
   std::string returnType =
@@ -4148,13 +4093,12 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesSingular
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, singularParams, definition, false, false, true );
-  std::string commandName =
-    stripPluralS( generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags ) );
-  std::string nodiscard  = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
-  std::string handleType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
-  std::string returnType = ( commandData.successCodes.size() == 1 )
-                             ? ( "typename ResultValueType<" + handleType + ">::type" )
-                             : ( "ResultValue<" + handleType + ">" );
+  std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
+  std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
+  std::string handleType  = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
+  std::string returnType  = ( commandData.successCodes.size() == 1 )
+                              ? ( "typename ResultValueType<" + handleType + ">::type" )
+                              : ( "ResultValue<" + handleType + ">" );
 
   if ( definition )
   {
@@ -4215,7 +4159,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUnique(
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocator, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string handleType  = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
   std::string returnType =
@@ -4337,13 +4281,12 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUniqueSi
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, singularParams, definition, false, false, true );
-  std::string commandName =
-    stripPluralS( generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags ) );
-  std::string nodiscard  = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
-  std::string handleType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
-  std::string returnType = ( commandData.successCodes.size() == 1 )
-                             ? ( "typename ResultValueType<UniqueHandle<" + handleType + ", Dispatch>>::type" )
-                             : ( "ResultValue<UniqueHandle<" + handleType + ", Dispatch>>" );
+  std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
+  std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
+  std::string handleType  = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
+  std::string returnType  = ( commandData.successCodes.size() == 1 )
+                              ? ( "typename ResultValueType<UniqueHandle<" + handleType + ", Dispatch>>::type" )
+                              : ( "ResultValue<UniqueHandle<" + handleType + ", Dispatch>>" );
 
   if ( definition )
   {
@@ -4408,10 +4351,9 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfVoidSingular(
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName =
-    stripPluralS( generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags ) );
-  std::string nodiscard  = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
-  std::string returnType = constructReturnType( commandData, "T" );
+  std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
+  std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
+  std::string returnType  = constructReturnType( commandData, "T" );
 
   if ( definition )
   {
@@ -4470,11 +4412,10 @@ std::string
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, singularParams, definition, false, false, true );
-  std::string commandName =
-    stripPluralS( generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags ) );
-  std::string nodiscard  = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
-  std::string dataType   = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
-  std::string returnType = constructReturnType( commandData, dataType );
+  std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
+  std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
+  std::string dataType    = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
+  std::string returnType  = constructReturnType( commandData, dataType );
 
   if ( definition )
   {
@@ -4526,10 +4467,9 @@ std::string VulkanHppGenerator::constructCommandStandard( std::string const & na
   std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, {}, {}, false );
 
   std::string argumentList = constructArgumentListStandard( commandData.params, skippedParams );
-  std::string commandName =
-    generateCommandName( name, initialSkipCount ? commandData.params[initialSkipCount - 1].type.type : "", m_tags );
-  std::string nodiscard  = constructNoDiscardStandard( commandData );
-  std::string returnType = stripPrefix( commandData.returnType, "Vk" );
+  std::string commandName  = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
+  std::string nodiscard    = constructNoDiscardStandard( commandData );
+  std::string returnType   = stripPrefix( commandData.returnType, "Vk" );
 
   if ( definition )
   {
@@ -4590,7 +4530,7 @@ std::string VulkanHppGenerator::constructCommandType( std::string const & name,
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnType  = stripPrefix( commandData.returnType, "Vk" );
 
@@ -4643,7 +4583,7 @@ std::string VulkanHppGenerator::constructCommandVoid( std::string const &
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string typenameT   = ( ( vectorParamIndices.size() == 1 ) &&
                             ( commandData.params[vectorParamIndices.begin()->first].type.type == "void" ) )
                               ? "typename T, "
@@ -4707,7 +4647,7 @@ std::string VulkanHppGenerator::constructCommandVoidEnumerate( std::string const
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocators, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName       = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string vectorElementType = stripPrefix( commandData.params[vectorParamIndex.first].type.type, "Vk" );
 
   if ( definition )
@@ -4792,7 +4732,7 @@ std::string
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocators, true, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   assert( beginsWith( commandData.params[vectorParamIndex.first].type.type, "Vk" ) );
   std::string vectorElementType =
     "VULKAN_HPP_NAMESPACE::" + stripPrefix( commandData.params[vectorParamIndex.first].type.type, "Vk" );
@@ -4877,7 +4817,7 @@ std::string VulkanHppGenerator::constructCommandVoidGetChain( std::string const
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   assert( beginsWith( commandData.params[nonConstPointerIndex].type.type, "Vk" ) );
   std::string returnType =
@@ -4936,7 +4876,7 @@ std::string VulkanHppGenerator::constructCommandVoidGetValue( std::string const
 
   std::string argumentList =
     constructArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, false, false, true );
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
   std::string returnType  = stripPostfix( commandData.params[returnParamIndex].type.compose(), "*" );
 
@@ -6114,8 +6054,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultEnumerate
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName = generateCommandName(
-    commandIt->first, initialSkipCount ? commandIt->second.params[initialSkipCount - 1].type.type : "", m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string vectorElementType = commandIt->second.params[vectorParamIndices.begin()->first].type.type;
   if ( !isHandleType( vectorElementType ) )
   {
@@ -6211,8 +6150,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultEnumerate
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   auto        firstVectorParamIt  = vectorParamIndices.begin();
   auto        secondVectorParamIt = std::next( firstVectorParamIt );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string counterName =
     startLowerCase( stripPrefix( stripPluralS( commandIt->second.params[firstVectorParamIt->second].name ), "p" ) );
   std::string firstType  = stripPrefix( commandIt->second.params[firstVectorParamIt->first].type.type, "Vk" );
@@ -6306,8 +6244,7 @@ std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMembe
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
   std::string argumentListDefinition =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string commandName = generateCommandName(
-    commandIt->first, initialSkipCount ? commandIt->second.params[initialSkipCount - 1].type.type : "", m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string enter, leave;
   std::tie( enter, leave )  = generateProtection( commandIt->second.referencedIn, std::string() );
   std::string callArguments = constructCallArgumentsEnhanced(
@@ -6381,8 +6318,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMulti(
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -6445,8 +6381,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetV
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
 
   if ( definition )
@@ -6509,8 +6444,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetV
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -6576,8 +6510,8 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetV
   std::set<size_t> singularParams = determineSingularParams( nonConstPointerParamIndices[0], vectorParamIndices );
   std::string      argumentList   = constructArgumentListEnhanced(
     commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
-  std::string commandName = stripPluralS(
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags ) );
+  std::string commandName =
+    stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
 
   if ( definition )
   {
@@ -6637,8 +6571,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiNoEr
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -6694,8 +6627,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingle(
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -6757,8 +6689,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGet
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -6823,8 +6754,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGet
     commandIt->second.params, initialSkipCount, vectorParamIndices, { returnParamIndex }, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string vectorElementType = commandIt->second.params[returnParamIndex].type.type;
 
   if ( definition )
@@ -6890,9 +6820,8 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGet
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string valueType         = commandIt->second.params[nonConstPointerParamIndices[1]].type.type;
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
+  std::string valueType   = commandIt->second.params[nonConstPointerParamIndices[1]].type.type;
   std::string vectorElementType = commandIt->second.params[nonConstPointerParamIndices[0]].type.type;
 
   if ( definition )
@@ -6967,8 +6896,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGet
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -7035,8 +6963,8 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGet
   std::set<size_t> singularParams = determineSingularParams( nonConstPointerParamIndices[0], vectorParamIndices );
   std::string      argumentList   = constructArgumentListEnhanced(
     commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
-  std::string commandName = stripPluralS(
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags ) );
+  std::string commandName =
+    stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
 
   if ( definition )
   {
@@ -7098,8 +7026,8 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGet
   std::set<size_t> singularParams = determineSingularParams( returnParamIndex, vectorParamIndices );
   std::string      argumentList   = constructArgumentListEnhanced(
     commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
-  std::string commandName = stripPluralS(
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags ) );
+  std::string commandName =
+    stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
   std::string vectorElementType = commandIt->second.params[returnParamIndex].type.type;
 
   if ( definition )
@@ -7161,8 +7089,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleNoE
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -7221,8 +7148,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGet
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName = generateCommandName(
-    commandIt->first, initialSkipCount ? commandIt->second.params[initialSkipCount - 1].type.type : "", m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
 
   if ( definition )
@@ -7290,8 +7216,7 @@ std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMembe
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
   std::string argumentListDefinition =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string enter, leave;
   std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn, std::string() );
   std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
@@ -7717,9 +7642,8 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionType(
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string returnType = generateNamespacedType( commandIt->second.returnType );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
+  std::string returnType  = generateNamespacedType( commandIt->second.returnType );
 
   if ( definition )
   {
@@ -7777,9 +7701,8 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVkType(
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string returnType = generateNamespacedType( commandIt->second.returnType );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
+  std::string returnType  = generateNamespacedType( commandIt->second.returnType );
 
   if ( definition )
   {
@@ -7889,8 +7812,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid0Return(
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
   std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT";
   std::string templateString = ( ( vectorParamIndices.size() == 1 ) &&
@@ -8054,8 +7976,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidEnumerate(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string vectorElementType =
     stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" );
 
@@ -8124,8 +8045,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidEnumerateCh
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string counterName =
     startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -8202,8 +8122,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidGetChain(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
 
   if ( definition )
   {
@@ -8266,8 +8185,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidGetValue(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
   std::string argumentList =
     constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
-  std::string commandName =
-    generateCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
   std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
   std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
   std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT";
@@ -8406,7 +8324,7 @@ std::string VulkanHppGenerator::constructRAIIHandleVectorSizeCheck(
     throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" );
   })#";
 
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
 
   std::string sizeChecks;
   for ( auto const & cvm : countToVectorMap )
@@ -8549,7 +8467,7 @@ std::string
     throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" );
   })#";
 
-  std::string commandName = generateCommandName( name, commandData.params[initialSkipCount - 1].type.type, m_tags );
+  std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
 
   std::string assertions, throws;
   for ( auto const & cvm : countToVectorMap )
@@ -9289,7 +9207,8 @@ void VulkanHppGenerator::appendUnion( std::string & str, std::pair<std::string,
          "\n"
          "  {\n"
          "#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )\n"
-         "    " + unionName + "( VULKAN_HPP_NAMESPACE::" + unionName +
+         "    " +
+         unionName + "( VULKAN_HPP_NAMESPACE::" + unionName +
          " const & rhs ) VULKAN_HPP_NOEXCEPT\n"
          "    {\n"
          "      memcpy( static_cast<void*>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::" +
@@ -10885,7 +10804,7 @@ std::string VulkanHppGenerator::generateCommandDefinitions( std::string const &
   str += generateCommand( commandIt->first, commandIt->second, handle.empty() ? 0 : 1, true );
 
   // special handling for destroy functions, filter out alias functions
-  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params[0].type.type, m_tags );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, 1, m_tags );
   if ( commandIt->second.alias.empty() &&
        ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
          ( commandIt->first.substr( 2, 4 ) == "Free" ) ||
@@ -10934,6 +10853,55 @@ std::string VulkanHppGenerator::generateCommandDefinitions( std::string const &
   return str;
 }
 
+std::string VulkanHppGenerator::generateCommandName( std::string const &            vulkanCommandName,
+                                                     std::vector<ParamData> const & params,
+                                                     size_t                         initialSkipCount,
+                                                     std::set<std::string> const &  tags ) const
+{
+  std::string commandName( startLowerCase( stripPrefix( vulkanCommandName, "vk" ) ) );
+  for ( size_t i = initialSkipCount - 1; i < initialSkipCount; --i )  // count down to zero, then wrap around and stop
+  {
+    std::string const & argumentType = params[i].type.type;
+    std::string         searchName   = stripPrefix( argumentType, "Vk" );
+    std::string         argumentTag  = findTag( tags, argumentType );
+    if ( !argumentTag.empty() )
+    {
+      searchName = stripPostfix( searchName, argumentTag );
+    }
+    size_t pos = commandName.find( searchName );
+    if ( ( pos == std::string::npos ) && isupper( searchName[0] ) )
+    {
+      searchName[0] = static_cast<char>( tolower( searchName[0] ) );
+      pos           = commandName.find( searchName );
+    }
+    if ( pos != std::string::npos )
+    {
+      size_t len = searchName.length();
+      if ( commandName.find( searchName + "s" ) == pos )
+      {
+        // filter out any plural of the searchName as well!
+        ++len;
+      }
+      commandName.erase( pos, len );
+    }
+    else if ( ( searchName == "commandBuffer" ) && beginsWith( commandName, "cmd" ) )
+    {
+      commandName.erase( 0, 3 );
+      pos = 0;
+    }
+    if ( ( pos == 0 ) && isupper( commandName[0] ) )
+    {
+      commandName[0] = static_cast<char>( tolower( commandName[0] ) );
+    }
+    std::string commandTag = findTag( tags, commandName );
+    if ( !argumentTag.empty() && ( argumentTag == commandTag ) )
+    {
+      commandName = stripPostfix( commandName, argumentTag );
+    }
+  }
+  return commandName;
+}
+
 std::string VulkanHppGenerator::generateCommandResult( std::string const & name,
                                                        CommandData const & commandData,
                                                        size_t              initialSkipCount,
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 7e21c2c..7a00971 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -930,6 +930,10 @@ private:
                                size_t              initialSkipCount,
                                bool                definition ) const;
   std::string generateCommandDefinitions( std::string const & command, std::string const & handle ) const;
+  std::string generateCommandName( std::string const &            vulkanCommandName,
+                                   std::vector<ParamData> const & params,
+                                   size_t                         initialSkipCount,
+                                   std::set<std::string> const &  tags ) const;
   std::string generateCommandResult( std::string const & name,
                                      CommandData const & commandData,
                                      size_t              initialSkipCount,
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 590c517..6f03501 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -53,6 +53,24 @@
 #  include <vector>
 #endif
 
+#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
+#  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+#    define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
+#  endif
+#  if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
+#    define VULKAN_HPP_NO_UNION_CONSTRUCTORS
+#  endif
+#endif
+
+#if defined( VULKAN_HPP_NO_SETTERS )
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+#    define VULKAN_HPP_NO_STRUCT_SETTERS
+#  endif
+#  if !defined( VULKAN_HPP_NO_UNION_SETTERS )
+#    define VULKAN_HPP_NO_UNION_SETTERS
+#  endif
+#endif
+
 #if !defined( VULKAN_HPP_ASSERT )
 #  include <cassert>
 #  define VULKAN_HPP_ASSERT assert
diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp
index 0502426..2951bf3 100644
--- a/vulkan/vulkan_raii.hpp
+++ b/vulkan/vulkan_raii.hpp
@@ -7626,7 +7626,7 @@ namespace VULKAN_HPP_NAMESPACE
       //=== VK_HUAWEI_subpass_shading ===
 
       VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D>
-                           getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI() const;
+                           getSubpassShadingMaxWorkgroupSizeHUAWEI() const;
 
     private:
       VULKAN_HPP_NAMESPACE::RenderPass                                          m_renderPass;
@@ -15980,7 +15980,7 @@ namespace VULKAN_HPP_NAMESPACE
     //=== VK_HUAWEI_subpass_shading ===
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D>
-                                           RenderPass::getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI() const
+                                           RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const
     {
       VULKAN_HPP_ASSERT(
         getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI &&
@@ -15995,8 +15995,8 @@ namespace VULKAN_HPP_NAMESPACE
       if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
            ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) )
       {
-        throwResultException(
-          result, VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" );
+        throwResultException( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI" );
       }
       return std::make_pair( result, maxWorkgroupSize );
     }
diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp
index 4f7e4f6..6428439 100644
--- a/vulkan/vulkan_structs.hpp
+++ b/vulkan/vulkan_structs.hpp
@@ -42,6 +42,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AabbPositionsKHR & setMinX( float minX_ ) VULKAN_HPP_NOEXCEPT
     {
       minX = minX_;
@@ -77,6 +78,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxZ = maxZ_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -118,6 +120,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union DeviceOrHostAddressConstKHR
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     DeviceOrHostAddressConstKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       memcpy( static_cast<void *>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR ) );
@@ -128,7 +131,9 @@ namespace VULKAN_HPP_NAMESPACE
     {}
 
     DeviceOrHostAddressConstKHR( const void * hostAddress_ ) : hostAddress( hostAddress_ ) {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     DeviceOrHostAddressConstKHR &
       setDeviceAddress( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -141,6 +146,7 @@ namespace VULKAN_HPP_NAMESPACE
       hostAddress = hostAddress_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR &
       operator=( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -212,6 +218,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureGeometryTrianglesDataKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -265,6 +272,7 @@ namespace VULKAN_HPP_NAMESPACE
       transformData = transformData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -332,6 +340,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureGeometryAabbsDataKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -351,6 +360,7 @@ namespace VULKAN_HPP_NAMESPACE
       stride = stride_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -414,6 +424,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureGeometryInstancesDataKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -433,6 +444,7 @@ namespace VULKAN_HPP_NAMESPACE
       data = data_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -464,6 +476,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union AccelerationStructureGeometryDataKHR
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     AccelerationStructureGeometryDataKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR const & rhs )
       VULKAN_HPP_NOEXCEPT
     {
@@ -483,7 +496,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR instances_ )
       : instances( instances_ )
     {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     AccelerationStructureGeometryDataKHR & setTriangles(
       VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -504,6 +519,7 @@ namespace VULKAN_HPP_NAMESPACE
       instances = instances_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR &
       operator=( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -564,6 +580,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureGeometryKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -589,6 +606,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -620,6 +638,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union DeviceOrHostAddressKHR
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     DeviceOrHostAddressKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       memcpy( static_cast<void *>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR ) );
@@ -629,7 +648,9 @@ namespace VULKAN_HPP_NAMESPACE
     {}
 
     DeviceOrHostAddressKHR( void * hostAddress_ ) : hostAddress( hostAddress_ ) {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     DeviceOrHostAddressKHR & setDeviceAddress( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ ) VULKAN_HPP_NOEXCEPT
     {
       deviceAddress = deviceAddress_;
@@ -641,6 +662,7 @@ namespace VULKAN_HPP_NAMESPACE
       hostAddress = hostAddress_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR &
       operator=( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -753,6 +775,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureBuildGeometryInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -807,7 +830,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     AccelerationStructureBuildGeometryInfoKHR & setGeometries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
         const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR> const & geometries_ ) VULKAN_HPP_NOEXCEPT
@@ -816,7 +839,7 @@ namespace VULKAN_HPP_NAMESPACE
       pGeometries   = geometries_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     AccelerationStructureBuildGeometryInfoKHR & setPpGeometries(
       const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const * ppGeometries_ ) VULKAN_HPP_NOEXCEPT
@@ -825,7 +848,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     AccelerationStructureBuildGeometryInfoKHR & setPGeometries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
         const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const> const & pGeometries_ ) VULKAN_HPP_NOEXCEPT
@@ -834,7 +857,7 @@ namespace VULKAN_HPP_NAMESPACE
       ppGeometries  = pGeometries_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     AccelerationStructureBuildGeometryInfoKHR &
       setScratchData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const & scratchData_ ) VULKAN_HPP_NOEXCEPT
@@ -842,6 +865,7 @@ namespace VULKAN_HPP_NAMESPACE
       scratchData = scratchData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -912,6 +936,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureBuildRangeInfoKHR & setPrimitiveCount( uint32_t primitiveCount_ ) VULKAN_HPP_NOEXCEPT
     {
       primitiveCount = primitiveCount_;
@@ -935,6 +960,7 @@ namespace VULKAN_HPP_NAMESPACE
       transformOffset = transformOffset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1007,6 +1033,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureBuildSizesInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1033,6 +1060,7 @@ namespace VULKAN_HPP_NAMESPACE
       buildScratchSize = buildScratchSize_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1119,6 +1147,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1163,6 +1192,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceAddress = deviceAddress_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1259,6 +1289,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GeometryTrianglesNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1330,6 +1361,7 @@ namespace VULKAN_HPP_NAMESPACE
       transformOffset = transformOffset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1416,6 +1448,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GeometryAABBNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1445,6 +1478,7 @@ namespace VULKAN_HPP_NAMESPACE
       offset = offset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1512,6 +1546,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GeometryDataNV & setTriangles( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & triangles_ ) VULKAN_HPP_NOEXCEPT
     {
       triangles = triangles_;
@@ -1523,6 +1558,7 @@ namespace VULKAN_HPP_NAMESPACE
       aabbs = aabbs_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1585,6 +1621,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GeometryNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1608,6 +1645,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1700,6 +1738,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1738,7 +1777,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     AccelerationStructureInfoNV & setGeometries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::GeometryNV> const & geometries_ )
       VULKAN_HPP_NOEXCEPT
@@ -1747,7 +1786,8 @@ namespace VULKAN_HPP_NAMESPACE
       pGeometries   = geometries_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1826,6 +1866,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1845,6 +1886,7 @@ namespace VULKAN_HPP_NAMESPACE
       info = info_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -1920,6 +1962,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureDeviceAddressInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -1932,6 +1975,7 @@ namespace VULKAN_HPP_NAMESPACE
       accelerationStructure = accelerationStructure_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2007,6 +2051,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureGeometryMotionTrianglesDataNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -2019,6 +2064,7 @@ namespace VULKAN_HPP_NAMESPACE
       vertexData = vertexData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2071,11 +2117,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     TransformMatrixKHR & setMatrix( std::array<std::array<float, 4>, 3> matrix_ ) VULKAN_HPP_NOEXCEPT
     {
       matrix = matrix_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2144,6 +2192,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureInstanceKHR &
       setTransform( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transform_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -2183,6 +2232,7 @@ namespace VULKAN_HPP_NAMESPACE
       accelerationStructureReference = accelerationStructureReference_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2265,6 +2315,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureMatrixMotionInstanceNV &
       setTransformT0( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformT0_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -2312,6 +2363,7 @@ namespace VULKAN_HPP_NAMESPACE
       accelerationStructureReference = accelerationStructureReference_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2390,6 +2442,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureMemoryRequirementsInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -2409,6 +2462,7 @@ namespace VULKAN_HPP_NAMESPACE
       accelerationStructure = accelerationStructure_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2485,6 +2539,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureMotionInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -2503,6 +2558,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2597,6 +2653,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SRTDataNV & setSx( float sx_ ) VULKAN_HPP_NOEXCEPT
     {
       sx = sx_;
@@ -2692,6 +2749,7 @@ namespace VULKAN_HPP_NAMESPACE
       tz = tz_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2781,6 +2839,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureSRTMotionInstanceNV &
       setTransformT0( VULKAN_HPP_NAMESPACE::SRTDataNV const & transformT0_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -2828,6 +2887,7 @@ namespace VULKAN_HPP_NAMESPACE
       accelerationStructureReference = accelerationStructureReference_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -2873,6 +2933,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union AccelerationStructureMotionInstanceDataNV
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     AccelerationStructureMotionInstanceDataNV(
       VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
@@ -2894,7 +2955,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV srtMotionInstance_ )
       : srtMotionInstance( srtMotionInstance_ )
     {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     AccelerationStructureMotionInstanceDataNV & setStaticInstance(
       VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & staticInstance_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -2916,6 +2979,7 @@ namespace VULKAN_HPP_NAMESPACE
       srtMotionInstance = srtMotionInstance_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV &
       operator=( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -2978,6 +3042,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureMotionInstanceNV &
       setType( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV type_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -2998,6 +3063,7 @@ namespace VULKAN_HPP_NAMESPACE
       data = data_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3049,6 +3115,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AccelerationStructureVersionInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -3060,6 +3127,7 @@ namespace VULKAN_HPP_NAMESPACE
       pVersionData = pVersionData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3135,6 +3203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AcquireNextImageInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -3170,6 +3239,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceMask = deviceMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3245,6 +3315,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AcquireProfilingLockInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -3263,6 +3334,7 @@ namespace VULKAN_HPP_NAMESPACE
       timeout = timeout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3338,6 +3410,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AllocationCallbacks & setPUserData( void * pUserData_ ) VULKAN_HPP_NOEXCEPT
     {
       pUserData = pUserData_;
@@ -3374,6 +3447,7 @@ namespace VULKAN_HPP_NAMESPACE
       pfnInternalFree = pfnInternalFree_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3443,6 +3517,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ComponentMapping & setR( VULKAN_HPP_NAMESPACE::ComponentSwizzle r_ ) VULKAN_HPP_NOEXCEPT
     {
       r = r_;
@@ -3466,6 +3541,7 @@ namespace VULKAN_HPP_NAMESPACE
       a = a_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3783,6 +3859,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AndroidSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -3801,6 +3878,7 @@ namespace VULKAN_HPP_NAMESPACE
       window = window_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3877,6 +3955,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ApplicationInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -3912,6 +3991,7 @@ namespace VULKAN_HPP_NAMESPACE
       apiVersion = apiVersion_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -3998,6 +4078,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AttachmentDescription & setFlags( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags_ ) VULKAN_HPP_NOEXCEPT
     {
       flags = flags_;
@@ -4053,6 +4134,7 @@ namespace VULKAN_HPP_NAMESPACE
       finalLayout = finalLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4140,6 +4222,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AttachmentDescription2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -4201,6 +4284,7 @@ namespace VULKAN_HPP_NAMESPACE
       finalLayout = finalLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4286,6 +4370,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AttachmentDescriptionStencilLayout & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -4305,6 +4390,7 @@ namespace VULKAN_HPP_NAMESPACE
       stencilFinalLayout = stencilFinalLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4375,6 +4461,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AttachmentReference & setAttachment( uint32_t attachment_ ) VULKAN_HPP_NOEXCEPT
     {
       attachment = attachment_;
@@ -4386,6 +4473,7 @@ namespace VULKAN_HPP_NAMESPACE
       layout = layout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4450,6 +4538,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AttachmentReference2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -4473,6 +4562,7 @@ namespace VULKAN_HPP_NAMESPACE
       aspectMask = aspectMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4546,6 +4636,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AttachmentReferenceStencilLayout & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -4558,6 +4649,7 @@ namespace VULKAN_HPP_NAMESPACE
       stencilLayout = stencilLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4621,6 +4713,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Extent2D & setWidth( uint32_t width_ ) VULKAN_HPP_NOEXCEPT
     {
       width = width_;
@@ -4632,6 +4725,7 @@ namespace VULKAN_HPP_NAMESPACE
       height = height_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4688,6 +4782,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SampleLocationEXT & setX( float x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -4699,6 +4794,7 @@ namespace VULKAN_HPP_NAMESPACE
       y = y_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4779,6 +4875,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SampleLocationsInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -4812,7 +4909,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SampleLocationsInfoEXT & setSampleLocations(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SampleLocationEXT> const &
         sampleLocations_ ) VULKAN_HPP_NOEXCEPT
@@ -4821,7 +4918,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSampleLocations     = sampleLocations_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4895,6 +4993,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     AttachmentSampleLocationsEXT & setAttachmentIndex( uint32_t attachmentIndex_ ) VULKAN_HPP_NOEXCEPT
     {
       attachmentIndex = attachmentIndex_;
@@ -4907,6 +5006,7 @@ namespace VULKAN_HPP_NAMESPACE
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -4963,11 +5063,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BaseInStructure & setPNext( const struct VULKAN_HPP_NAMESPACE::BaseInStructure * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5022,11 +5124,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BaseOutStructure & setPNext( struct VULKAN_HPP_NAMESPACE::BaseOutStructure * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5113,6 +5217,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindAccelerationStructureMemoryInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -5151,7 +5256,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindAccelerationStructureMemoryInfoNV & setDeviceIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -5159,7 +5264,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDeviceIndices   = deviceIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5244,6 +5350,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindBufferMemoryDeviceGroupInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -5262,7 +5369,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindBufferMemoryDeviceGroupInfo & setDeviceIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -5270,7 +5377,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDeviceIndices   = deviceIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5345,6 +5453,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindBufferMemoryInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -5368,6 +5477,7 @@ namespace VULKAN_HPP_NAMESPACE
       memoryOffset = memoryOffset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5433,6 +5543,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Offset2D & setX( int32_t x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -5444,6 +5555,7 @@ namespace VULKAN_HPP_NAMESPACE
       y = y_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5498,6 +5610,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Rect2D & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT
     {
       offset = offset_;
@@ -5509,6 +5622,7 @@ namespace VULKAN_HPP_NAMESPACE
       extent = extent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5587,6 +5701,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindImageMemoryDeviceGroupInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -5605,7 +5720,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindImageMemoryDeviceGroupInfo & setDeviceIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -5613,7 +5728,7 @@ namespace VULKAN_HPP_NAMESPACE
       pDeviceIndices   = deviceIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     BindImageMemoryDeviceGroupInfo &
       setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) VULKAN_HPP_NOEXCEPT
@@ -5629,7 +5744,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Rect2D> const &
         splitInstanceBindRegions_ ) VULKAN_HPP_NOEXCEPT
@@ -5638,7 +5753,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSplitInstanceBindRegions    = splitInstanceBindRegions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5717,6 +5833,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindImageMemoryInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -5740,6 +5857,7 @@ namespace VULKAN_HPP_NAMESPACE
       memoryOffset = memoryOffset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5813,6 +5931,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindImageMemorySwapchainInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -5830,6 +5949,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageIndex = imageIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5901,6 +6021,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindImagePlaneMemoryInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -5913,6 +6034,7 @@ namespace VULKAN_HPP_NAMESPACE
       planeAspect = planeAspect_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -5983,6 +6105,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindIndexBufferIndirectCommandNV &
       setBufferAddress( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -6001,6 +6124,7 @@ namespace VULKAN_HPP_NAMESPACE
       indexType = indexType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6060,11 +6184,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindShaderGroupIndirectCommandNV & setGroupIndex( uint32_t groupIndex_ ) VULKAN_HPP_NOEXCEPT
     {
       groupIndex = groupIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6128,6 +6254,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SparseMemoryBind & setResourceOffset( VULKAN_HPP_NAMESPACE::DeviceSize resourceOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       resourceOffset = resourceOffset_;
@@ -6157,6 +6284,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6231,6 +6359,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SparseBufferMemoryBindInfo & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
     {
       buffer = buffer_;
@@ -6249,7 +6378,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SparseBufferMemoryBindInfo & setBinds(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SparseMemoryBind> const & binds_ )
       VULKAN_HPP_NOEXCEPT
@@ -6258,7 +6387,8 @@ namespace VULKAN_HPP_NAMESPACE
       pBinds    = binds_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6331,6 +6461,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SparseImageOpaqueMemoryBindInfo & setImage( VULKAN_HPP_NAMESPACE::Image image_ ) VULKAN_HPP_NOEXCEPT
     {
       image = image_;
@@ -6350,7 +6481,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SparseImageOpaqueMemoryBindInfo & setBinds(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SparseMemoryBind> const & binds_ )
       VULKAN_HPP_NOEXCEPT
@@ -6359,7 +6490,8 @@ namespace VULKAN_HPP_NAMESPACE
       pBinds    = binds_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6421,6 +6553,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageSubresource & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -6438,6 +6571,7 @@ namespace VULKAN_HPP_NAMESPACE
       arrayLayer = arrayLayer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6496,6 +6630,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Offset3D & setX( int32_t x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -6513,6 +6648,7 @@ namespace VULKAN_HPP_NAMESPACE
       z = z_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6573,6 +6709,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Extent3D & setWidth( uint32_t width_ ) VULKAN_HPP_NOEXCEPT
     {
       width = width_;
@@ -6590,6 +6727,7 @@ namespace VULKAN_HPP_NAMESPACE
       depth = depth_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6657,6 +6795,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SparseImageMemoryBind &
       setSubresource( VULKAN_HPP_NAMESPACE::ImageSubresource const & subresource_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -6693,6 +6832,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6768,6 +6908,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SparseImageMemoryBindInfo & setImage( VULKAN_HPP_NAMESPACE::Image image_ ) VULKAN_HPP_NOEXCEPT
     {
       image = image_;
@@ -6787,7 +6928,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SparseImageMemoryBindInfo & setBinds(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind> const & binds_ )
       VULKAN_HPP_NOEXCEPT
@@ -6796,7 +6937,8 @@ namespace VULKAN_HPP_NAMESPACE
       pBinds    = binds_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -6900,6 +7042,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindSparseInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -6918,7 +7061,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindSparseInfo & setWaitSemaphores(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Semaphore> const & waitSemaphores_ )
       VULKAN_HPP_NOEXCEPT
@@ -6927,7 +7070,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitSemaphores    = waitSemaphores_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     BindSparseInfo & setBufferBindCount( uint32_t bufferBindCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -6942,7 +7085,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindSparseInfo & setBufferBinds(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo> const &
         bufferBinds_ ) VULKAN_HPP_NOEXCEPT
@@ -6951,7 +7094,7 @@ namespace VULKAN_HPP_NAMESPACE
       pBufferBinds    = bufferBinds_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     BindSparseInfo & setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -6966,7 +7109,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindSparseInfo & setImageOpaqueBinds(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo> const &
         imageOpaqueBinds_ ) VULKAN_HPP_NOEXCEPT
@@ -6975,7 +7118,7 @@ namespace VULKAN_HPP_NAMESPACE
       pImageOpaqueBinds    = imageOpaqueBinds_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     BindSparseInfo & setImageBindCount( uint32_t imageBindCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -6990,7 +7133,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindSparseInfo & setImageBinds(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo> const &
         imageBinds_ ) VULKAN_HPP_NOEXCEPT
@@ -6999,7 +7142,7 @@ namespace VULKAN_HPP_NAMESPACE
       pImageBinds    = imageBinds_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     BindSparseInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -7014,7 +7157,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BindSparseInfo & setSignalSemaphores(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Semaphore> const & signalSemaphores_ )
       VULKAN_HPP_NOEXCEPT
@@ -7023,7 +7166,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSignalSemaphores    = signalSemaphores_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7105,6 +7249,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BindVertexBufferIndirectCommandNV &
       setBufferAddress( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -7123,6 +7268,7 @@ namespace VULKAN_HPP_NAMESPACE
       stride = stride_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7187,6 +7333,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageSubresourceLayers & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -7210,6 +7357,7 @@ namespace VULKAN_HPP_NAMESPACE
       layerCount = layerCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7278,6 +7426,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageBlit2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -7311,6 +7460,7 @@ namespace VULKAN_HPP_NAMESPACE
       dstOffsets = dstOffsets_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageBlit2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7412,6 +7562,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BlitImageInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -7454,7 +7605,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BlitImageInfo2KHR & setRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ImageBlit2KHR> const & regions_ )
       VULKAN_HPP_NOEXCEPT
@@ -7463,13 +7614,14 @@ namespace VULKAN_HPP_NAMESPACE
       pRegions    = regions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     BlitImageInfo2KHR & setFilter( VULKAN_HPP_NAMESPACE::Filter filter_ ) VULKAN_HPP_NOEXCEPT
     {
       filter = filter_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBlitImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7545,6 +7697,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferCopy & setSrcOffset( VULKAN_HPP_NAMESPACE::DeviceSize srcOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       srcOffset = srcOffset_;
@@ -7562,6 +7715,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7624,6 +7778,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferCopy2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -7647,6 +7802,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7740,6 +7896,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -7782,7 +7939,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     BufferCreateInfo & setQueueFamilyIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -7790,7 +7947,8 @@ namespace VULKAN_HPP_NAMESPACE
       pQueueFamilyIndices   = queueFamilyIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7867,6 +8025,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferDeviceAddressCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -7879,6 +8038,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceAddress = deviceAddress_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -7946,6 +8106,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferDeviceAddressInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -7957,6 +8118,7 @@ namespace VULKAN_HPP_NAMESPACE
       buffer = buffer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8031,6 +8193,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferImageCopy & setBufferOffset( VULKAN_HPP_NAMESPACE::DeviceSize bufferOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       bufferOffset = bufferOffset_;
@@ -8067,6 +8230,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageExtent = imageExtent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8141,6 +8305,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferImageCopy2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -8183,6 +8348,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageExtent = imageExtent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8269,6 +8435,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferMemoryBarrier & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -8316,6 +8483,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8407,6 +8575,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferMemoryBarrier2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -8470,6 +8639,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8549,6 +8719,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -8560,6 +8731,7 @@ namespace VULKAN_HPP_NAMESPACE
       buffer = buffer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8631,6 +8803,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferOpaqueCaptureAddressCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -8642,6 +8815,7 @@ namespace VULKAN_HPP_NAMESPACE
       opaqueCaptureAddress = opaqueCaptureAddress_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8719,6 +8893,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     BufferViewCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -8754,6 +8929,7 @@ namespace VULKAN_HPP_NAMESPACE
       range = range_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -8828,6 +9004,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CalibratedTimestampInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -8839,6 +9016,7 @@ namespace VULKAN_HPP_NAMESPACE
       timeDomain = timeDomain_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9020,6 +9198,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union ClearColorValue
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     ClearColorValue( VULKAN_HPP_NAMESPACE::ClearColorValue const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       memcpy( static_cast<void *>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::ClearColorValue ) );
@@ -9030,7 +9209,9 @@ namespace VULKAN_HPP_NAMESPACE
     ClearColorValue( const std::array<int32_t, 4> & int32_ ) : int32( int32_ ) {}
 
     ClearColorValue( const std::array<uint32_t, 4> & uint32_ ) : uint32( uint32_ ) {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     ClearColorValue & setFloat32( std::array<float, 4> float32_ ) VULKAN_HPP_NOEXCEPT
     {
       float32 = float32_;
@@ -9048,6 +9229,7 @@ namespace VULKAN_HPP_NAMESPACE
       uint32 = uint32_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::ClearColorValue &
       operator=( VULKAN_HPP_NAMESPACE::ClearColorValue const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -9095,6 +9277,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ClearDepthStencilValue & setDepth( float depth_ ) VULKAN_HPP_NOEXCEPT
     {
       depth = depth_;
@@ -9106,6 +9289,7 @@ namespace VULKAN_HPP_NAMESPACE
       stencil = stencil_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9141,6 +9325,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union ClearValue
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     ClearValue( VULKAN_HPP_NAMESPACE::ClearValue const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       memcpy( static_cast<void *>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::ClearValue ) );
@@ -9149,7 +9334,9 @@ namespace VULKAN_HPP_NAMESPACE
     ClearValue( VULKAN_HPP_NAMESPACE::ClearColorValue color_ = {} ) : color( color_ ) {}
 
     ClearValue( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue depthStencil_ ) : depthStencil( depthStencil_ ) {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     ClearValue & setColor( VULKAN_HPP_NAMESPACE::ClearColorValue const & color_ ) VULKAN_HPP_NOEXCEPT
     {
       color = color_;
@@ -9162,6 +9349,7 @@ namespace VULKAN_HPP_NAMESPACE
       depthStencil = depthStencil_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::ClearValue & operator=( VULKAN_HPP_NAMESPACE::ClearValue const & rhs ) VULKAN_HPP_NOEXCEPT
     {
@@ -9214,6 +9402,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ClearAttachment & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -9231,6 +9420,7 @@ namespace VULKAN_HPP_NAMESPACE
       clearValue = clearValue_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9275,6 +9465,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ClearRect & setRect( VULKAN_HPP_NAMESPACE::Rect2D const & rect_ ) VULKAN_HPP_NOEXCEPT
     {
       rect = rect_;
@@ -9292,6 +9483,7 @@ namespace VULKAN_HPP_NAMESPACE
       layerCount = layerCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9351,6 +9543,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CoarseSampleLocationNV & setPixelX( uint32_t pixelX_ ) VULKAN_HPP_NOEXCEPT
     {
       pixelX = pixelX_;
@@ -9368,6 +9561,7 @@ namespace VULKAN_HPP_NAMESPACE
       sample = sample_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9447,6 +9641,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CoarseSampleOrderCustomNV &
       setShadingRate( VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV shadingRate_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -9473,7 +9668,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     CoarseSampleOrderCustomNV & setSampleLocations(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV> const &
         sampleLocations_ ) VULKAN_HPP_NOEXCEPT
@@ -9482,7 +9677,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSampleLocations    = sampleLocations_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9553,6 +9749,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandBufferAllocateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -9576,6 +9773,7 @@ namespace VULKAN_HPP_NAMESPACE
       commandBufferCount = commandBufferCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9658,6 +9856,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandBufferInheritanceInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -9702,6 +9901,7 @@ namespace VULKAN_HPP_NAMESPACE
       pipelineStatistics = pipelineStatistics_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9780,6 +9980,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandBufferBeginInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -9798,6 +9999,7 @@ namespace VULKAN_HPP_NAMESPACE
       pInheritanceInfo = pInheritanceInfo_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9873,6 +10075,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandBufferInheritanceConditionalRenderingInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -9885,6 +10088,7 @@ namespace VULKAN_HPP_NAMESPACE
       conditionalRenderingEnable = conditionalRenderingEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -9964,6 +10168,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandBufferInheritanceRenderPassTransformInfoQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -9983,6 +10188,7 @@ namespace VULKAN_HPP_NAMESPACE
       renderArea = renderArea_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10058,6 +10264,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Viewport & setX( float x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -10093,6 +10300,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxDepth = maxDepth_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkViewport const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10166,6 +10374,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandBufferInheritanceViewportScissorInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -10192,6 +10401,7 @@ namespace VULKAN_HPP_NAMESPACE
       pViewportDepths = pViewportDepths_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10266,6 +10476,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandBufferSubmitInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -10284,6 +10495,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceMask = deviceMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandBufferSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10355,6 +10567,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CommandPoolCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -10372,6 +10585,7 @@ namespace VULKAN_HPP_NAMESPACE
       queueFamilyIndex = queueFamilyIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10440,6 +10654,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SpecializationMapEntry & setConstantID( uint32_t constantID_ ) VULKAN_HPP_NOEXCEPT
     {
       constantID = constantID_;
@@ -10457,6 +10672,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10532,6 +10748,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SpecializationInfo & setMapEntryCount( uint32_t mapEntryCount_ ) VULKAN_HPP_NOEXCEPT
     {
       mapEntryCount = mapEntryCount_;
@@ -10545,7 +10762,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SpecializationInfo & setMapEntries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SpecializationMapEntry> const &
         mapEntries_ ) VULKAN_HPP_NOEXCEPT
@@ -10554,7 +10771,7 @@ namespace VULKAN_HPP_NAMESPACE
       pMapEntries   = mapEntries_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SpecializationInfo & setDataSize( size_t dataSize_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -10568,7 +10785,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     template <typename T>
     SpecializationInfo &
       setData( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const T> const & data_ ) VULKAN_HPP_NOEXCEPT
@@ -10577,7 +10794,8 @@ namespace VULKAN_HPP_NAMESPACE
       pData    = data_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10650,6 +10868,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineShaderStageCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -10687,6 +10906,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSpecializationInfo = pSpecializationInfo_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10768,6 +10988,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ComputePipelineCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -10805,6 +11026,7 @@ namespace VULKAN_HPP_NAMESPACE
       basePipelineIndex = basePipelineIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10884,6 +11106,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ConditionalRenderingBeginInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -10908,6 +11131,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -10981,6 +11205,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ConformanceVersion & setMajor( uint8_t major_ ) VULKAN_HPP_NOEXCEPT
     {
       major = major_;
@@ -11004,6 +11229,7 @@ namespace VULKAN_HPP_NAMESPACE
       patch = patch_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11082,6 +11308,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CooperativeMatrixPropertiesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11135,6 +11362,7 @@ namespace VULKAN_HPP_NAMESPACE
       scope = scope_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11218,6 +11446,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyAccelerationStructureInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11242,6 +11471,7 @@ namespace VULKAN_HPP_NAMESPACE
       mode = mode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11324,6 +11554,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyAccelerationStructureToMemoryInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11350,6 +11581,7 @@ namespace VULKAN_HPP_NAMESPACE
       mode = mode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11426,6 +11658,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyBufferInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11456,7 +11689,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     CopyBufferInfo2KHR & setRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::BufferCopy2KHR> const & regions_ )
       VULKAN_HPP_NOEXCEPT
@@ -11465,7 +11698,8 @@ namespace VULKAN_HPP_NAMESPACE
       pRegions    = regions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11560,6 +11794,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyBufferToImageInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11598,7 +11833,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     CopyBufferToImageInfo2KHR & setRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR> const & regions_ )
       VULKAN_HPP_NOEXCEPT
@@ -11607,7 +11842,8 @@ namespace VULKAN_HPP_NAMESPACE
       pRegions    = regions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyBufferToImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11684,6 +11920,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyCommandTransformInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11696,6 +11933,7 @@ namespace VULKAN_HPP_NAMESPACE
       transform = transform_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11776,6 +12014,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyDescriptorSet & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11823,6 +12062,7 @@ namespace VULKAN_HPP_NAMESPACE
       descriptorCount = descriptorCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -11905,6 +12145,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageCopy2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -11942,6 +12183,7 @@ namespace VULKAN_HPP_NAMESPACE
       extent = extent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12040,6 +12282,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyImageInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12082,7 +12325,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     CopyImageInfo2KHR & setRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ImageCopy2KHR> const & regions_ )
       VULKAN_HPP_NOEXCEPT
@@ -12091,7 +12334,8 @@ namespace VULKAN_HPP_NAMESPACE
       pRegions    = regions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12190,6 +12434,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyImageToBufferInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12228,7 +12473,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     CopyImageToBufferInfo2KHR & setRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR> const & regions_ )
       VULKAN_HPP_NOEXCEPT
@@ -12237,7 +12482,8 @@ namespace VULKAN_HPP_NAMESPACE
       pRegions    = regions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyImageToBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12322,6 +12568,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CopyMemoryToAccelerationStructureInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12348,6 +12595,7 @@ namespace VULKAN_HPP_NAMESPACE
       mode = mode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12407,6 +12655,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CuFunctionCreateInfoNVX & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12424,6 +12673,7 @@ namespace VULKAN_HPP_NAMESPACE
       pName = pName_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12538,6 +12788,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CuLaunchInfoNVX & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12604,7 +12855,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     CuLaunchInfoNVX &
       setParams( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const void * const> const & params_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -12612,7 +12863,7 @@ namespace VULKAN_HPP_NAMESPACE
       pParams    = params_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     CuLaunchInfoNVX & setExtraCount( size_t extraCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -12626,7 +12877,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     CuLaunchInfoNVX &
       setExtras( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const void * const> const & extras_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -12634,7 +12885,8 @@ namespace VULKAN_HPP_NAMESPACE
       pExtras    = extras_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12716,6 +12968,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     CuModuleCreateInfoNVX & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12733,6 +12986,7 @@ namespace VULKAN_HPP_NAMESPACE
       pData = pData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12818,6 +13072,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     D3D12FenceSubmitInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12836,7 +13091,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     D3D12FenceSubmitInfoKHR & setWaitSemaphoreValues(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & waitSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -12844,7 +13099,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitSemaphoreValues     = waitSemaphoreValues_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     D3D12FenceSubmitInfoKHR & setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -12858,7 +13113,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     D3D12FenceSubmitInfoKHR & setSignalSemaphoreValues(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & signalSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -12866,7 +13121,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSignalSemaphoreValues     = signalSemaphoreValues_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -12944,6 +13200,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugMarkerMarkerInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -12961,6 +13218,7 @@ namespace VULKAN_HPP_NAMESPACE
       color = color_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13035,6 +13293,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugMarkerObjectNameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13059,6 +13318,7 @@ namespace VULKAN_HPP_NAMESPACE
       pObjectName = pObjectName_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13154,6 +13414,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugMarkerObjectTagInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13191,7 +13452,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     template <typename T>
     DebugMarkerObjectTagInfoEXT &
       setTag( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const T> const & tag_ ) VULKAN_HPP_NOEXCEPT
@@ -13200,7 +13461,8 @@ namespace VULKAN_HPP_NAMESPACE
       pTag    = tag_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13280,6 +13542,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugReportCallbackCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13303,6 +13566,7 @@ namespace VULKAN_HPP_NAMESPACE
       pUserData = pUserData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13375,6 +13639,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugUtilsLabelEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13392,6 +13657,7 @@ namespace VULKAN_HPP_NAMESPACE
       color = color_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13466,6 +13732,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugUtilsObjectNameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13489,6 +13756,7 @@ namespace VULKAN_HPP_NAMESPACE
       pObjectName = pObjectName_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13606,6 +13874,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugUtilsMessengerCallbackDataEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13650,7 +13919,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DebugUtilsMessengerCallbackDataEXT & setQueueLabels(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT> const &
         queueLabels_ ) VULKAN_HPP_NOEXCEPT
@@ -13659,7 +13928,7 @@ namespace VULKAN_HPP_NAMESPACE
       pQueueLabels    = queueLabels_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DebugUtilsMessengerCallbackDataEXT & setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -13674,7 +13943,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DebugUtilsMessengerCallbackDataEXT & setCmdBufLabels(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT> const &
         cmdBufLabels_ ) VULKAN_HPP_NOEXCEPT
@@ -13683,7 +13952,7 @@ namespace VULKAN_HPP_NAMESPACE
       pCmdBufLabels    = cmdBufLabels_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DebugUtilsMessengerCallbackDataEXT & setObjectCount( uint32_t objectCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -13698,7 +13967,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DebugUtilsMessengerCallbackDataEXT & setObjects(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT> const &
         objects_ ) VULKAN_HPP_NOEXCEPT
@@ -13707,7 +13976,8 @@ namespace VULKAN_HPP_NAMESPACE
       pObjects    = objects_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13799,6 +14069,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugUtilsMessengerCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13838,6 +14109,7 @@ namespace VULKAN_HPP_NAMESPACE
       pUserData = pUserData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -13935,6 +14207,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DebugUtilsObjectTagInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -13971,7 +14244,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     template <typename T>
     DebugUtilsObjectTagInfoEXT &
       setTag( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const T> const & tag_ ) VULKAN_HPP_NOEXCEPT
@@ -13980,7 +14253,8 @@ namespace VULKAN_HPP_NAMESPACE
       pTag    = tag_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14058,6 +14332,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DedicatedAllocationBufferCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -14070,6 +14345,7 @@ namespace VULKAN_HPP_NAMESPACE
       dedicatedAllocation = dedicatedAllocation_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14141,6 +14417,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DedicatedAllocationImageCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -14153,6 +14430,7 @@ namespace VULKAN_HPP_NAMESPACE
       dedicatedAllocation = dedicatedAllocation_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14227,6 +14505,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DedicatedAllocationMemoryAllocateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -14244,6 +14523,7 @@ namespace VULKAN_HPP_NAMESPACE
       buffer = buffer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14320,6 +14600,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryBarrier2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -14351,6 +14632,7 @@ namespace VULKAN_HPP_NAMESPACE
       dstAccessMask = dstAccessMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14427,6 +14709,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageSubresourceRange & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -14456,6 +14739,7 @@ namespace VULKAN_HPP_NAMESPACE
       layerCount = layerCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14539,6 +14823,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageMemoryBarrier2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -14609,6 +14894,7 @@ namespace VULKAN_HPP_NAMESPACE
       subresourceRange = subresourceRange_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14721,6 +15007,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DependencyInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -14746,7 +15033,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DependencyInfoKHR & setMemoryBarriers(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR> const &
         memoryBarriers_ ) VULKAN_HPP_NOEXCEPT
@@ -14755,7 +15042,7 @@ namespace VULKAN_HPP_NAMESPACE
       pMemoryBarriers    = memoryBarriers_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DependencyInfoKHR & setBufferMemoryBarrierCount( uint32_t bufferMemoryBarrierCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -14770,7 +15057,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DependencyInfoKHR & setBufferMemoryBarriers(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR> const &
         bufferMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT
@@ -14779,7 +15066,7 @@ namespace VULKAN_HPP_NAMESPACE
       pBufferMemoryBarriers    = bufferMemoryBarriers_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DependencyInfoKHR & setImageMemoryBarrierCount( uint32_t imageMemoryBarrierCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -14794,7 +15081,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DependencyInfoKHR & setImageMemoryBarriers(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR> const &
         imageMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT
@@ -14803,7 +15090,8 @@ namespace VULKAN_HPP_NAMESPACE
       pImageMemoryBarriers    = imageMemoryBarriers_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDependencyInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14882,6 +15170,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorBufferInfo & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
     {
       buffer = buffer_;
@@ -14899,6 +15188,7 @@ namespace VULKAN_HPP_NAMESPACE
       range = range_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -14961,6 +15251,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorImageInfo & setSampler( VULKAN_HPP_NAMESPACE::Sampler sampler_ ) VULKAN_HPP_NOEXCEPT
     {
       sampler = sampler_;
@@ -14978,6 +15269,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageLayout = imageLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15038,6 +15330,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorPoolSize & setType( VULKAN_HPP_NAMESPACE::DescriptorType type_ ) VULKAN_HPP_NOEXCEPT
     {
       type = type_;
@@ -15049,6 +15342,7 @@ namespace VULKAN_HPP_NAMESPACE
       descriptorCount = descriptorCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15127,6 +15421,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorPoolCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -15158,7 +15453,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DescriptorPoolCreateInfo & setPoolSizes(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorPoolSize> const & poolSizes_ )
       VULKAN_HPP_NOEXCEPT
@@ -15167,7 +15462,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPoolSizes    = poolSizes_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15244,6 +15540,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorPoolInlineUniformBlockCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -15256,6 +15553,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15342,6 +15640,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorSetAllocateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -15368,7 +15667,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DescriptorSetAllocateInfo & setSetLayouts(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const &
         setLayouts_ ) VULKAN_HPP_NOEXCEPT
@@ -15377,7 +15676,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSetLayouts        = setLayouts_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15469,6 +15769,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorSetLayoutBinding & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
     {
       binding = binding_;
@@ -15501,7 +15802,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DescriptorSetLayoutBinding & setImmutableSamplers(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Sampler> const & immutableSamplers_ )
       VULKAN_HPP_NOEXCEPT
@@ -15510,7 +15811,8 @@ namespace VULKAN_HPP_NAMESPACE
       pImmutableSamplers = immutableSamplers_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15592,6 +15894,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorSetLayoutBindingFlagsCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -15611,7 +15914,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DescriptorSetLayoutBindingFlagsCreateInfo & setBindingFlags(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags> const &
         bindingFlags_ ) VULKAN_HPP_NOEXCEPT
@@ -15620,7 +15923,8 @@ namespace VULKAN_HPP_NAMESPACE
       pBindingFlags = bindingFlags_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15707,6 +16011,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorSetLayoutCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -15733,7 +16038,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DescriptorSetLayoutCreateInfo & setBindings(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding> const &
         bindings_ ) VULKAN_HPP_NOEXCEPT
@@ -15742,7 +16047,8 @@ namespace VULKAN_HPP_NAMESPACE
       pBindings    = bindings_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -15897,6 +16203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorSetVariableDescriptorCountAllocateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -15917,7 +16224,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DescriptorSetVariableDescriptorCountAllocateInfo & setDescriptorCounts(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & descriptorCounts_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -15925,7 +16232,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDescriptorCounts  = descriptorCounts_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -16082,6 +16390,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorUpdateTemplateEntry & setDstBinding( uint32_t dstBinding_ ) VULKAN_HPP_NOEXCEPT
     {
       dstBinding = dstBinding_;
@@ -16118,6 +16427,7 @@ namespace VULKAN_HPP_NAMESPACE
       stride = stride_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -16226,6 +16536,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DescriptorUpdateTemplateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -16253,7 +16564,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DescriptorUpdateTemplateCreateInfo & setDescriptorUpdateEntries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry> const &
         descriptorUpdateEntries_ ) VULKAN_HPP_NOEXCEPT
@@ -16262,7 +16573,7 @@ namespace VULKAN_HPP_NAMESPACE
       pDescriptorUpdateEntries   = descriptorUpdateEntries_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DescriptorUpdateTemplateCreateInfo &
       setTemplateType( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType templateType_ ) VULKAN_HPP_NOEXCEPT
@@ -16297,6 +16608,7 @@ namespace VULKAN_HPP_NAMESPACE
       set = set_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -16394,6 +16706,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceQueueCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -16424,7 +16737,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceQueueCreateInfo & setQueuePriorities(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const float> const & queuePriorities_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -16432,7 +16745,8 @@ namespace VULKAN_HPP_NAMESPACE
       pQueuePriorities = queuePriorities_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -16610,6 +16924,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFeatures &
       setRobustBufferAccess( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -16973,6 +17288,7 @@ namespace VULKAN_HPP_NAMESPACE
       inheritedQueries = inheritedQueries_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17157,6 +17473,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17182,7 +17499,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceCreateInfo & setQueueCreateInfos(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo> const &
         queueCreateInfos_ ) VULKAN_HPP_NOEXCEPT
@@ -17191,7 +17508,7 @@ namespace VULKAN_HPP_NAMESPACE
       pQueueCreateInfos    = queueCreateInfos_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -17205,7 +17522,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceCreateInfo & setPEnabledLayerNames( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const char * const> const &
                                                 pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -17213,7 +17530,7 @@ namespace VULKAN_HPP_NAMESPACE
       ppEnabledLayerNames = pEnabledLayerNames_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DeviceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -17227,7 +17544,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceCreateInfo & setPEnabledExtensionNames(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const char * const> const & pEnabledExtensionNames_ )
       VULKAN_HPP_NOEXCEPT
@@ -17236,7 +17553,7 @@ namespace VULKAN_HPP_NAMESPACE
       ppEnabledExtensionNames = pEnabledExtensionNames_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DeviceCreateInfo &
       setPEnabledFeatures( const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pEnabledFeatures_ ) VULKAN_HPP_NOEXCEPT
@@ -17244,6 +17561,7 @@ namespace VULKAN_HPP_NAMESPACE
       pEnabledFeatures = pEnabledFeatures_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17330,6 +17648,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceDeviceMemoryReportCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17355,6 +17674,7 @@ namespace VULKAN_HPP_NAMESPACE
       pUserData = pUserData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17428,6 +17748,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceDiagnosticsConfigCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17440,6 +17761,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17509,6 +17831,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceEventInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17520,6 +17843,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceEvent = deviceEvent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17589,6 +17913,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceGroupBindSparseInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17606,6 +17931,7 @@ namespace VULKAN_HPP_NAMESPACE
       memoryDeviceIndex = memoryDeviceIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17678,6 +18004,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceGroupCommandBufferBeginInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17689,6 +18016,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceMask = deviceMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17770,6 +18098,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceGroupDeviceCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17789,7 +18118,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceGroupDeviceCreateInfo & setPhysicalDevices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PhysicalDevice> const &
         physicalDevices_ ) VULKAN_HPP_NOEXCEPT
@@ -17798,7 +18127,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPhysicalDevices    = physicalDevices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -17959,6 +18289,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceGroupPresentInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -17977,7 +18308,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceGroupPresentInfoKHR & setDeviceMasks(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & deviceMasks_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -17985,7 +18316,7 @@ namespace VULKAN_HPP_NAMESPACE
       pDeviceMasks   = deviceMasks_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DeviceGroupPresentInfoKHR &
       setMode( VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR mode_ ) VULKAN_HPP_NOEXCEPT
@@ -17993,6 +18324,7 @@ namespace VULKAN_HPP_NAMESPACE
       mode = mode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18080,6 +18412,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceGroupRenderPassBeginInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18105,7 +18438,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceGroupRenderPassBeginInfo & setDeviceRenderAreas(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Rect2D> const & deviceRenderAreas_ )
       VULKAN_HPP_NOEXCEPT
@@ -18114,7 +18447,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDeviceRenderAreas    = deviceRenderAreas_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18211,6 +18545,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceGroupSubmitInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18230,7 +18565,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceGroupSubmitInfo & setWaitSemaphoreDeviceIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & waitSemaphoreDeviceIndices_ )
       VULKAN_HPP_NOEXCEPT
@@ -18239,7 +18574,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitSemaphoreDeviceIndices = waitSemaphoreDeviceIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DeviceGroupSubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -18254,7 +18589,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceGroupSubmitInfo & setCommandBufferDeviceMasks(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & commandBufferDeviceMasks_ )
       VULKAN_HPP_NOEXCEPT
@@ -18263,7 +18598,7 @@ namespace VULKAN_HPP_NAMESPACE
       pCommandBufferDeviceMasks = commandBufferDeviceMasks_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     DeviceGroupSubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -18278,7 +18613,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     DeviceGroupSubmitInfo & setSignalSemaphoreDeviceIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & signalSemaphoreDeviceIndices_ )
       VULKAN_HPP_NOEXCEPT
@@ -18287,7 +18622,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSignalSemaphoreDeviceIndices = signalSemaphoreDeviceIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18367,6 +18703,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceGroupSwapchainCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18379,6 +18716,7 @@ namespace VULKAN_HPP_NAMESPACE
       modes = modes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18450,6 +18788,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceMemoryOpaqueCaptureAddressInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18461,6 +18800,7 @@ namespace VULKAN_HPP_NAMESPACE
       memory = memory_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18535,6 +18875,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceMemoryOverallocationCreateInfoAMD & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18547,6 +18888,7 @@ namespace VULKAN_HPP_NAMESPACE
       overallocationBehavior = overallocationBehavior_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18710,6 +19052,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DevicePrivateDataCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18722,6 +19065,7 @@ namespace VULKAN_HPP_NAMESPACE
       privateDataSlotRequestCount = privateDataSlotRequestCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDevicePrivateDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18796,6 +19140,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceQueueGlobalPriorityCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18808,6 +19153,7 @@ namespace VULKAN_HPP_NAMESPACE
       globalPriority = globalPriority_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceQueueGlobalPriorityCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18878,6 +19224,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DeviceQueueInfo2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18901,6 +19248,7 @@ namespace VULKAN_HPP_NAMESPACE
       queueIndex = queueIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -18976,6 +19324,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DirectFBSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -19000,6 +19349,7 @@ namespace VULKAN_HPP_NAMESPACE
       surface = surface_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -19071,6 +19421,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DispatchIndirectCommand & setX( uint32_t x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -19088,6 +19439,7 @@ namespace VULKAN_HPP_NAMESPACE
       z = z_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -19150,6 +19502,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DisplayEventInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -19161,6 +19514,7 @@ namespace VULKAN_HPP_NAMESPACE
       displayEvent = displayEvent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -19226,6 +19580,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DisplayModeParametersKHR &
       setVisibleRegion( VULKAN_HPP_NAMESPACE::Extent2D const & visibleRegion_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -19238,6 +19593,7 @@ namespace VULKAN_HPP_NAMESPACE
       refreshRate = refreshRate_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -19300,6 +19656,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DisplayModeCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -19318,6 +19675,7 @@ namespace VULKAN_HPP_NAMESPACE
       parameters = parameters_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -19738,6 +20096,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DisplayPlaneInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -19755,6 +20114,7 @@ namespace VULKAN_HPP_NAMESPACE
       planeIndex = planeIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -19952,6 +20312,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DisplayPowerInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -19963,6 +20324,7 @@ namespace VULKAN_HPP_NAMESPACE
       powerState = powerState_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20033,6 +20395,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DisplayPresentInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -20056,6 +20419,7 @@ namespace VULKAN_HPP_NAMESPACE
       persistent = persistent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20285,6 +20649,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DisplaySurfaceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -20343,6 +20708,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageExtent = imageExtent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20428,6 +20794,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DrawIndexedIndirectCommand & setIndexCount( uint32_t indexCount_ ) VULKAN_HPP_NOEXCEPT
     {
       indexCount = indexCount_;
@@ -20457,6 +20824,7 @@ namespace VULKAN_HPP_NAMESPACE
       firstInstance = firstInstance_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20525,6 +20893,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DrawIndirectCommand & setVertexCount( uint32_t vertexCount_ ) VULKAN_HPP_NOEXCEPT
     {
       vertexCount = vertexCount_;
@@ -20548,6 +20917,7 @@ namespace VULKAN_HPP_NAMESPACE
       firstInstance = firstInstance_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20610,6 +20980,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     DrawMeshTasksIndirectCommandNV & setTaskCount( uint32_t taskCount_ ) VULKAN_HPP_NOEXCEPT
     {
       taskCount = taskCount_;
@@ -20621,6 +20992,7 @@ namespace VULKAN_HPP_NAMESPACE
       firstTask = firstTask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20829,6 +21201,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     EventCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -20840,6 +21213,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20906,6 +21280,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportFenceCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -20918,6 +21293,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleTypes = handleTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -20991,6 +21367,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportFenceWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21014,6 +21391,7 @@ namespace VULKAN_HPP_NAMESPACE
       name = name_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -21086,6 +21464,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportMemoryAllocateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21098,6 +21477,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleTypes = handleTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -21167,6 +21547,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportMemoryAllocateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21179,6 +21560,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleTypes = handleTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -21252,6 +21634,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportMemoryWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21275,6 +21658,7 @@ namespace VULKAN_HPP_NAMESPACE
       name = name_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -21350,6 +21734,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportMemoryWin32HandleInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21367,6 +21752,7 @@ namespace VULKAN_HPP_NAMESPACE
       dwAccess = dwAccess_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -21439,6 +21825,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportSemaphoreCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21451,6 +21838,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleTypes = handleTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -21526,6 +21914,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExportSemaphoreWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21549,6 +21938,7 @@ namespace VULKAN_HPP_NAMESPACE
       name = name_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -21887,6 +22277,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExternalFormatANDROID & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -21898,6 +22289,7 @@ namespace VULKAN_HPP_NAMESPACE
       externalFormat = externalFormat_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -22175,6 +22567,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExternalMemoryBufferCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -22187,6 +22580,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleTypes = handleTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -22257,6 +22651,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExternalMemoryImageCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -22269,6 +22664,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleTypes = handleTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -22339,6 +22735,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ExternalMemoryImageCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -22351,6 +22748,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleTypes = handleTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -22495,6 +22893,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     FenceCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -22506,6 +22905,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -22575,6 +22975,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     FenceGetFdInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -22593,6 +22994,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -22668,6 +23070,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     FenceGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -22686,6 +23089,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -22968,6 +23372,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     FragmentShadingRateAttachmentInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -22987,6 +23392,7 @@ namespace VULKAN_HPP_NAMESPACE
       shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -23089,6 +23495,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     FramebufferAttachmentImageInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -23138,7 +23545,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     FramebufferAttachmentImageInfo & setViewFormats(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Format> const & viewFormats_ )
       VULKAN_HPP_NOEXCEPT
@@ -23147,7 +23554,8 @@ namespace VULKAN_HPP_NAMESPACE
       pViewFormats    = viewFormats_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -23237,6 +23645,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     FramebufferAttachmentsCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -23257,7 +23666,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     FramebufferAttachmentsCreateInfo & setAttachmentImageInfos(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo> const &
         attachmentImageInfos_ ) VULKAN_HPP_NOEXCEPT
@@ -23266,7 +23675,8 @@ namespace VULKAN_HPP_NAMESPACE
       pAttachmentImageInfos    = attachmentImageInfos_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -23368,6 +23778,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     FramebufferCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -23398,7 +23809,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     FramebufferCreateInfo & setAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ImageView> const & attachments_ )
       VULKAN_HPP_NOEXCEPT
@@ -23407,7 +23818,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAttachments    = attachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     FramebufferCreateInfo & setWidth( uint32_t width_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -23426,6 +23837,7 @@ namespace VULKAN_HPP_NAMESPACE
       layers = layers_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -23584,6 +23996,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     IndirectCommandsStreamNV & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
     {
       buffer = buffer_;
@@ -23595,6 +24008,7 @@ namespace VULKAN_HPP_NAMESPACE
       offset = offset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -23710,6 +24124,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GeneratedCommandsInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -23749,7 +24164,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     GeneratedCommandsInfoNV & setStreams(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV> const &
         streams_ ) VULKAN_HPP_NOEXCEPT
@@ -23758,7 +24173,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStreams    = streams_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     GeneratedCommandsInfoNV & setSequencesCount( uint32_t sequencesCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -23812,6 +24227,7 @@ namespace VULKAN_HPP_NAMESPACE
       sequencesIndexOffset = sequencesIndexOffset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -23910,6 +24326,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GeneratedCommandsMemoryRequirementsInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -23942,6 +24359,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxSequencesCount = maxSequencesCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24019,6 +24437,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VertexInputBindingDescription & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
     {
       binding = binding_;
@@ -24036,6 +24455,7 @@ namespace VULKAN_HPP_NAMESPACE
       inputRate = inputRate_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24102,6 +24522,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VertexInputAttributeDescription & setLocation( uint32_t location_ ) VULKAN_HPP_NOEXCEPT
     {
       location = location_;
@@ -24125,6 +24546,7 @@ namespace VULKAN_HPP_NAMESPACE
       offset = offset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24216,6 +24638,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineVertexInputStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -24243,7 +24666,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineVertexInputStateCreateInfo & setVertexBindingDescriptions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription> const &
         vertexBindingDescriptions_ ) VULKAN_HPP_NOEXCEPT
@@ -24252,7 +24675,7 @@ namespace VULKAN_HPP_NAMESPACE
       pVertexBindingDescriptions    = vertexBindingDescriptions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     PipelineVertexInputStateCreateInfo &
       setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) VULKAN_HPP_NOEXCEPT
@@ -24268,7 +24691,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineVertexInputStateCreateInfo & setVertexAttributeDescriptions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription> const &
         vertexAttributeDescriptions_ ) VULKAN_HPP_NOEXCEPT
@@ -24277,7 +24700,8 @@ namespace VULKAN_HPP_NAMESPACE
       pVertexAttributeDescriptions    = vertexAttributeDescriptions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24361,6 +24785,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineInputAssemblyStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -24387,6 +24812,7 @@ namespace VULKAN_HPP_NAMESPACE
       primitiveRestartEnable = primitiveRestartEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24463,6 +24889,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineTessellationStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -24481,6 +24908,7 @@ namespace VULKAN_HPP_NAMESPACE
       patchControlPoints = patchControlPoints_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24573,6 +25001,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineViewportStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -24599,7 +25028,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineViewportStateCreateInfo & setViewports(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports_ )
       VULKAN_HPP_NOEXCEPT
@@ -24608,7 +25037,7 @@ namespace VULKAN_HPP_NAMESPACE
       pViewports    = viewports_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     PipelineViewportStateCreateInfo & setScissorCount( uint32_t scissorCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -24623,7 +25052,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineViewportStateCreateInfo &
       setScissors( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors_ )
         VULKAN_HPP_NOEXCEPT
@@ -24632,7 +25061,8 @@ namespace VULKAN_HPP_NAMESPACE
       pScissors    = scissors_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24730,6 +25160,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRasterizationStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -24809,6 +25240,7 @@ namespace VULKAN_HPP_NAMESPACE
       lineWidth = lineWidth_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -24908,6 +25340,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineMultisampleStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -24961,6 +25394,7 @@ namespace VULKAN_HPP_NAMESPACE
       alphaToOneEnable = alphaToOneEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -25047,6 +25481,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     StencilOpState & setFailOp( VULKAN_HPP_NAMESPACE::StencilOp failOp_ ) VULKAN_HPP_NOEXCEPT
     {
       failOp = failOp_;
@@ -25088,6 +25523,7 @@ namespace VULKAN_HPP_NAMESPACE
       reference = reference_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -25175,6 +25611,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineDepthStencilStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -25248,6 +25685,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxDepthBounds = maxDepthBounds_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -25341,6 +25779,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineColorBlendAttachmentState & setBlendEnable( VULKAN_HPP_NAMESPACE::Bool32 blendEnable_ ) VULKAN_HPP_NOEXCEPT
     {
       blendEnable = blendEnable_;
@@ -25395,6 +25834,7 @@ namespace VULKAN_HPP_NAMESPACE
       colorWriteMask = colorWriteMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -25494,6 +25934,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineColorBlendStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -25533,7 +25974,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineColorBlendStateCreateInfo & setAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
         const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState> const & attachments_ ) VULKAN_HPP_NOEXCEPT
@@ -25542,13 +25983,14 @@ namespace VULKAN_HPP_NAMESPACE
       pAttachments    = attachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     PipelineColorBlendStateCreateInfo & setBlendConstants( std::array<float, 4> blendConstants_ ) VULKAN_HPP_NOEXCEPT
     {
       blendConstants = blendConstants_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -25640,6 +26082,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineDynamicStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -25666,7 +26109,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineDynamicStateCreateInfo & setDynamicStates(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DynamicState> const & dynamicStates_ )
       VULKAN_HPP_NOEXCEPT
@@ -25675,7 +26118,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDynamicStates    = dynamicStates_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -25819,6 +26263,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GraphicsPipelineCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -25844,7 +26289,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     GraphicsPipelineCreateInfo & setStages(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> const &
         stages_ ) VULKAN_HPP_NOEXCEPT
@@ -25853,7 +26298,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStages    = stages_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     GraphicsPipelineCreateInfo & setPVertexInputState(
       const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo * pVertexInputState_ ) VULKAN_HPP_NOEXCEPT
@@ -25948,6 +26393,7 @@ namespace VULKAN_HPP_NAMESPACE
       basePipelineIndex = basePipelineIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26060,6 +26506,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GraphicsShaderGroupCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -26079,7 +26526,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     GraphicsShaderGroupCreateInfoNV & setStages(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> const &
         stages_ ) VULKAN_HPP_NOEXCEPT
@@ -26088,7 +26535,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStages    = stages_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     GraphicsShaderGroupCreateInfoNV & setPVertexInputState(
       const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo * pVertexInputState_ ) VULKAN_HPP_NOEXCEPT
@@ -26103,6 +26550,7 @@ namespace VULKAN_HPP_NAMESPACE
       pTessellationState = pTessellationState_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26199,6 +26647,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     GraphicsPipelineShaderGroupsCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -26218,7 +26667,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     GraphicsPipelineShaderGroupsCreateInfoNV & setGroups(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV> const &
         groups_ ) VULKAN_HPP_NOEXCEPT
@@ -26227,7 +26676,7 @@ namespace VULKAN_HPP_NAMESPACE
       pGroups    = groups_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     GraphicsPipelineShaderGroupsCreateInfoNV & setPipelineCount( uint32_t pipelineCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -26242,7 +26691,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     GraphicsPipelineShaderGroupsCreateInfoNV & setPipelines(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Pipeline> const & pipelines_ )
       VULKAN_HPP_NOEXCEPT
@@ -26251,7 +26700,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPipelines    = pipelines_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26321,6 +26771,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     XYColorEXT & setX( float x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -26332,6 +26783,7 @@ namespace VULKAN_HPP_NAMESPACE
       y = y_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26403,6 +26855,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     HdrMetadataEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -26459,6 +26912,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxFrameAverageLightLevel = maxFrameAverageLightLevel_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26536,6 +26990,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     HeadlessSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -26548,6 +27003,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26618,6 +27074,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     IOSSurfaceCreateInfoMVK & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -26635,6 +27092,7 @@ namespace VULKAN_HPP_NAMESPACE
       pView = pView_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26705,6 +27163,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageBlit &
       setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -26730,6 +27189,7 @@ namespace VULKAN_HPP_NAMESPACE
       dstOffsets = dstOffsets_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26794,6 +27254,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageCopy &
       setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -26825,6 +27286,7 @@ namespace VULKAN_HPP_NAMESPACE
       extent = extent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -26941,6 +27403,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -27019,7 +27482,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ImageCreateInfo & setQueueFamilyIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -27027,13 +27490,14 @@ namespace VULKAN_HPP_NAMESPACE
       pQueueFamilyIndices   = queueFamilyIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     ImageCreateInfo & setInitialLayout( VULKAN_HPP_NAMESPACE::ImageLayout initialLayout_ ) VULKAN_HPP_NOEXCEPT
     {
       initialLayout = initialLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -27204,6 +27668,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageDrmFormatModifierExplicitCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -27231,7 +27696,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ImageDrmFormatModifierExplicitCreateInfoEXT & setPlaneLayouts(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SubresourceLayout> const &
         planeLayouts_ ) VULKAN_HPP_NOEXCEPT
@@ -27240,7 +27705,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPlaneLayouts               = planeLayouts_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -27328,6 +27794,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageDrmFormatModifierListCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -27348,7 +27815,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifiers(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & drmFormatModifiers_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -27356,7 +27823,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDrmFormatModifiers    = drmFormatModifiers_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -27508,6 +27976,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageFormatListCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -27527,7 +27996,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ImageFormatListCreateInfo & setViewFormats(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Format> const & viewFormats_ )
       VULKAN_HPP_NOEXCEPT
@@ -27536,7 +28005,8 @@ namespace VULKAN_HPP_NAMESPACE
       pViewFormats    = viewFormats_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -27689,6 +28159,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageMemoryBarrier & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -27743,6 +28214,7 @@ namespace VULKAN_HPP_NAMESPACE
       subresourceRange = subresourceRange_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -27821,6 +28293,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -27832,6 +28305,7 @@ namespace VULKAN_HPP_NAMESPACE
       image = image_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -27906,6 +28380,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImagePipeSurfaceCreateInfoFUCHSIA & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -27924,6 +28399,7 @@ namespace VULKAN_HPP_NAMESPACE
       imagePipeHandle = imagePipeHandle_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -27997,6 +28473,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImagePlaneMemoryRequirementsInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28009,6 +28486,7 @@ namespace VULKAN_HPP_NAMESPACE
       planeAspect = planeAspect_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28081,6 +28559,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageResolve &
       setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -28112,6 +28591,7 @@ namespace VULKAN_HPP_NAMESPACE
       extent = extent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28181,6 +28661,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageResolve2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28218,6 +28699,7 @@ namespace VULKAN_HPP_NAMESPACE
       extent = extent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageResolve2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28294,6 +28776,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageSparseMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28305,6 +28788,7 @@ namespace VULKAN_HPP_NAMESPACE
       image = image_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28375,6 +28859,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageStencilUsageCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28387,6 +28872,7 @@ namespace VULKAN_HPP_NAMESPACE
       stencilUsage = stencilUsage_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28457,6 +28943,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageSwapchainCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28468,6 +28955,7 @@ namespace VULKAN_HPP_NAMESPACE
       swapchain = swapchain_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28537,6 +29025,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageViewASTCDecodeModeEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28548,6 +29037,7 @@ namespace VULKAN_HPP_NAMESPACE
       decodeMode = decodeMode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28698,6 +29188,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageViewCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28741,6 +29232,7 @@ namespace VULKAN_HPP_NAMESPACE
       subresourceRange = subresourceRange_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28819,6 +29311,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageViewHandleInfoNVX & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28843,6 +29336,7 @@ namespace VULKAN_HPP_NAMESPACE
       sampler = sampler_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28913,6 +29407,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImageViewUsageCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -28924,6 +29419,7 @@ namespace VULKAN_HPP_NAMESPACE
       usage = usage_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -28997,6 +29493,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportAndroidHardwareBufferInfoANDROID & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29008,6 +29505,7 @@ namespace VULKAN_HPP_NAMESPACE
       buffer = buffer_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29083,6 +29581,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportFenceFdInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29113,6 +29612,7 @@ namespace VULKAN_HPP_NAMESPACE
       fd = fd_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29196,6 +29696,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportFenceWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29232,6 +29733,7 @@ namespace VULKAN_HPP_NAMESPACE
       name = name_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29309,6 +29811,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportMemoryFdInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29327,6 +29830,7 @@ namespace VULKAN_HPP_NAMESPACE
       fd = fd_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29400,6 +29904,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportMemoryHostPointerInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29418,6 +29923,7 @@ namespace VULKAN_HPP_NAMESPACE
       pHostPointer = pHostPointer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29496,6 +30002,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportMemoryWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29520,6 +30027,7 @@ namespace VULKAN_HPP_NAMESPACE
       name = name_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29597,6 +30105,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportMemoryWin32HandleInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29615,6 +30124,7 @@ namespace VULKAN_HPP_NAMESPACE
       handle = handle_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29693,6 +30203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportMemoryZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29711,6 +30222,7 @@ namespace VULKAN_HPP_NAMESPACE
       handle = handle_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29790,6 +30302,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportSemaphoreFdInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29820,6 +30333,7 @@ namespace VULKAN_HPP_NAMESPACE
       fd = fd_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -29904,6 +30418,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportSemaphoreWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -29941,6 +30456,7 @@ namespace VULKAN_HPP_NAMESPACE
       name = name_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -30029,6 +30545,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ImportSemaphoreZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -30061,6 +30578,7 @@ namespace VULKAN_HPP_NAMESPACE
       zirconHandle = zirconHandle_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -30203,6 +30721,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     IndirectCommandsLayoutTokenNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -30287,7 +30806,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     IndirectCommandsLayoutTokenNV & setIndexTypes(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::IndexType> const & indexTypes_ )
       VULKAN_HPP_NOEXCEPT
@@ -30296,7 +30815,7 @@ namespace VULKAN_HPP_NAMESPACE
       pIndexTypes    = indexTypes_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     IndirectCommandsLayoutTokenNV & setPIndexTypeValues( const uint32_t * pIndexTypeValues_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -30304,7 +30823,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     IndirectCommandsLayoutTokenNV & setIndexTypeValues(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & indexTypeValues_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -30312,7 +30831,8 @@ namespace VULKAN_HPP_NAMESPACE
       pIndexTypeValues = indexTypeValues_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -30430,6 +30950,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     IndirectCommandsLayoutCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -30463,7 +30984,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     IndirectCommandsLayoutCreateInfoNV & setTokens(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV> const &
         tokens_ ) VULKAN_HPP_NOEXCEPT
@@ -30472,7 +30993,7 @@ namespace VULKAN_HPP_NAMESPACE
       pTokens    = tokens_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     IndirectCommandsLayoutCreateInfoNV & setStreamCount( uint32_t streamCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -30486,7 +31007,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     IndirectCommandsLayoutCreateInfoNV & setStreamStrides(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & streamStrides_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -30494,7 +31015,8 @@ namespace VULKAN_HPP_NAMESPACE
       pStreamStrides = streamStrides_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -30572,6 +31094,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     InitializePerformanceApiInfoINTEL & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -30583,6 +31106,7 @@ namespace VULKAN_HPP_NAMESPACE
       pUserData = pUserData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -30653,6 +31177,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     InputAttachmentAspectReference & setSubpass( uint32_t subpass_ ) VULKAN_HPP_NOEXCEPT
     {
       subpass = subpass_;
@@ -30671,6 +31196,7 @@ namespace VULKAN_HPP_NAMESPACE
       aspectMask = aspectMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -30759,6 +31285,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     InstanceCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -30790,7 +31317,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     InstanceCreateInfo & setPEnabledLayerNames(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const char * const> const & pEnabledLayerNames_ )
       VULKAN_HPP_NOEXCEPT
@@ -30799,7 +31326,7 @@ namespace VULKAN_HPP_NAMESPACE
       ppEnabledLayerNames = pEnabledLayerNames_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     InstanceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -30813,7 +31340,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     InstanceCreateInfo & setPEnabledExtensionNames(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const char * const> const & pEnabledExtensionNames_ )
       VULKAN_HPP_NOEXCEPT
@@ -30822,7 +31349,8 @@ namespace VULKAN_HPP_NAMESPACE
       ppEnabledExtensionNames = pEnabledExtensionNames_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -30965,6 +31493,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MacOSSurfaceCreateInfoMVK & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -30982,6 +31511,7 @@ namespace VULKAN_HPP_NAMESPACE
       pView = pView_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31055,6 +31585,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MappedMemoryRange & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31078,6 +31609,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31149,6 +31681,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryAllocateFlagsInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31166,6 +31699,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceMask = deviceMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31237,6 +31771,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryAllocateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31254,6 +31789,7 @@ namespace VULKAN_HPP_NAMESPACE
       memoryTypeIndex = memoryTypeIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31323,6 +31859,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryBarrier & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31340,6 +31877,7 @@ namespace VULKAN_HPP_NAMESPACE
       dstAccessMask = dstAccessMask_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31410,6 +31948,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryDedicatedAllocateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31427,6 +31966,7 @@ namespace VULKAN_HPP_NAMESPACE
       buffer = buffer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31642,6 +32182,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryGetAndroidHardwareBufferInfoANDROID & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31654,6 +32195,7 @@ namespace VULKAN_HPP_NAMESPACE
       memory = memory_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31727,6 +32269,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryGetFdInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31745,6 +32288,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31819,6 +32363,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryGetRemoteAddressInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31837,6 +32382,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -31913,6 +32459,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -31931,6 +32478,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -32008,6 +32556,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryGetZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -32026,6 +32575,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -32224,6 +32774,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryOpaqueCaptureAddressAllocateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -32236,6 +32787,7 @@ namespace VULKAN_HPP_NAMESPACE
       opaqueCaptureAddress = opaqueCaptureAddress_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -32305,6 +32857,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MemoryPriorityAllocateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -32316,6 +32869,7 @@ namespace VULKAN_HPP_NAMESPACE
       priority = priority_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -32709,6 +33263,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MetalSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -32726,6 +33281,7 @@ namespace VULKAN_HPP_NAMESPACE
       pLayer = pLayer_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -32796,6 +33352,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MultiDrawIndexedInfoEXT & setFirstIndex( uint32_t firstIndex_ ) VULKAN_HPP_NOEXCEPT
     {
       firstIndex = firstIndex_;
@@ -32813,6 +33370,7 @@ namespace VULKAN_HPP_NAMESPACE
       vertexOffset = vertexOffset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -32871,6 +33429,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MultiDrawInfoEXT & setFirstVertex( uint32_t firstVertex_ ) VULKAN_HPP_NOEXCEPT
     {
       firstVertex = firstVertex_;
@@ -32882,6 +33441,7 @@ namespace VULKAN_HPP_NAMESPACE
       vertexCount = vertexCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33018,6 +33578,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MutableDescriptorTypeListVALVE & setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) VULKAN_HPP_NOEXCEPT
     {
       descriptorTypeCount = descriptorTypeCount_;
@@ -33031,7 +33592,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     MutableDescriptorTypeListVALVE & setDescriptorTypes(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorType> const &
         descriptorTypes_ ) VULKAN_HPP_NOEXCEPT
@@ -33040,7 +33601,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDescriptorTypes    = descriptorTypes_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33117,6 +33679,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     MutableDescriptorTypeCreateInfoVALVE & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -33137,7 +33700,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     MutableDescriptorTypeCreateInfoVALVE & setMutableDescriptorTypeLists(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const &
         mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT
@@ -33146,7 +33709,8 @@ namespace VULKAN_HPP_NAMESPACE
       pMutableDescriptorTypeLists    = mutableDescriptorTypeLists_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33294,6 +33858,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PerformanceConfigurationAcquireInfoINTEL & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -33306,6 +33871,7 @@ namespace VULKAN_HPP_NAMESPACE
       type = type_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33509,6 +34075,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union PerformanceCounterResultKHR
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       memcpy( static_cast<void *>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR ) );
@@ -33525,7 +34092,9 @@ namespace VULKAN_HPP_NAMESPACE
     PerformanceCounterResultKHR( float float32_ ) : float32( float32_ ) {}
 
     PerformanceCounterResultKHR( double float64_ ) : float64( float64_ ) {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     PerformanceCounterResultKHR & setInt32( int32_t int32_ ) VULKAN_HPP_NOEXCEPT
     {
       int32 = int32_;
@@ -33561,6 +34130,7 @@ namespace VULKAN_HPP_NAMESPACE
       float64 = float64_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR &
       operator=( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -33612,6 +34182,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PerformanceMarkerInfoINTEL & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -33623,6 +34194,7 @@ namespace VULKAN_HPP_NAMESPACE
       marker = marker_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33697,6 +34269,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PerformanceOverrideInfoINTEL & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -33721,6 +34294,7 @@ namespace VULKAN_HPP_NAMESPACE
       parameter = parameter_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33793,6 +34367,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PerformanceQuerySubmitInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -33804,6 +34379,7 @@ namespace VULKAN_HPP_NAMESPACE
       counterPassIndex = counterPassIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33872,6 +34448,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PerformanceStreamMarkerInfoINTEL & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -33883,6 +34460,7 @@ namespace VULKAN_HPP_NAMESPACE
       marker = marker_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -33926,6 +34504,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union PerformanceValueDataINTEL
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     PerformanceValueDataINTEL( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       memcpy( static_cast<void *>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL ) );
@@ -33938,7 +34517,9 @@ namespace VULKAN_HPP_NAMESPACE
     PerformanceValueDataINTEL( float valueFloat_ ) : valueFloat( valueFloat_ ) {}
 
     PerformanceValueDataINTEL( const char * valueString_ ) : valueString( valueString_ ) {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     PerformanceValueDataINTEL & setValue32( uint32_t value32_ ) VULKAN_HPP_NOEXCEPT
     {
       value32 = value32_;
@@ -33968,6 +34549,7 @@ namespace VULKAN_HPP_NAMESPACE
       valueString = valueString_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL &
       operator=( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -34026,6 +34608,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PerformanceValueINTEL & setType( VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type_ ) VULKAN_HPP_NOEXCEPT
     {
       type = type_;
@@ -34037,6 +34620,7 @@ namespace VULKAN_HPP_NAMESPACE
       data = data_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -34092,6 +34676,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevice16BitStorageFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -34125,6 +34710,7 @@ namespace VULKAN_HPP_NAMESPACE
       storageInputOutput16 = storageInputOutput16_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -34206,6 +34792,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevice4444FormatsFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -34225,6 +34812,7 @@ namespace VULKAN_HPP_NAMESPACE
       formatA4B4G4R4 = formatA4B4G4R4_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -34301,6 +34889,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevice8BitStorageFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -34327,6 +34916,7 @@ namespace VULKAN_HPP_NAMESPACE
       storagePushConstant8 = storagePushConstant8_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -34404,6 +34994,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceASTCDecodeFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -34416,6 +35007,7 @@ namespace VULKAN_HPP_NAMESPACE
       decodeModeSharedExponent = decodeModeSharedExponent_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -34498,6 +35090,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceAccelerationStructureFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -34538,6 +35131,7 @@ namespace VULKAN_HPP_NAMESPACE
       descriptorBindingAccelerationStructureUpdateAfterBind = descriptorBindingAccelerationStructureUpdateAfterBind_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -34725,6 +35319,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -34737,6 +35332,7 @@ namespace VULKAN_HPP_NAMESPACE
       advancedBlendCoherentOperations = advancedBlendCoherentOperations_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -34911,6 +35507,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceBufferDeviceAddressFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -34937,6 +35534,7 @@ namespace VULKAN_HPP_NAMESPACE
       bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35020,6 +35618,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceBufferDeviceAddressFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35046,6 +35645,7 @@ namespace VULKAN_HPP_NAMESPACE
       bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35124,6 +35724,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceCoherentMemoryFeaturesAMD & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35136,6 +35737,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceCoherentMemory = deviceCoherentMemory_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35209,6 +35811,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceColorWriteEnableFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35221,6 +35824,7 @@ namespace VULKAN_HPP_NAMESPACE
       colorWriteEnable = colorWriteEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35297,6 +35901,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceComputeShaderDerivativesFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35316,6 +35921,7 @@ namespace VULKAN_HPP_NAMESPACE
       computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35395,6 +36001,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceConditionalRenderingFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35414,6 +36021,7 @@ namespace VULKAN_HPP_NAMESPACE
       inheritedConditionalRendering = inheritedConditionalRendering_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35599,6 +36207,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceCooperativeMatrixFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35618,6 +36227,7 @@ namespace VULKAN_HPP_NAMESPACE
       cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35768,6 +36378,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceCornerSampledImageFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35780,6 +36391,7 @@ namespace VULKAN_HPP_NAMESPACE
       cornerSampledImage = cornerSampledImage_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35854,6 +36466,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceCoverageReductionModeFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35866,6 +36479,7 @@ namespace VULKAN_HPP_NAMESPACE
       coverageReductionMode = coverageReductionMode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -35942,6 +36556,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceCustomBorderColorFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -35961,6 +36576,7 @@ namespace VULKAN_HPP_NAMESPACE
       customBorderColorWithoutFormat = customBorderColorWithoutFormat_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -36112,6 +36728,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -36124,6 +36741,7 @@ namespace VULKAN_HPP_NAMESPACE
       dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -36200,6 +36818,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceDepthClipEnableFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -36212,6 +36831,7 @@ namespace VULKAN_HPP_NAMESPACE
       depthClipEnable = depthClipEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -36411,6 +37031,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceDescriptorIndexingFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -36556,6 +37177,7 @@ namespace VULKAN_HPP_NAMESPACE
       runtimeDescriptorArray = runtimeDescriptorArray_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -36849,6 +37471,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -36861,6 +37484,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceGeneratedCommands = deviceGeneratedCommands_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37043,6 +37667,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceDeviceMemoryReportFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37055,6 +37680,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceMemoryReport = deviceMemoryReport_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37129,6 +37755,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceDiagnosticsConfigFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37141,6 +37768,7 @@ namespace VULKAN_HPP_NAMESPACE
       diagnosticsConfig = diagnosticsConfig_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37452,6 +38080,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExclusiveScissorFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37464,6 +38093,7 @@ namespace VULKAN_HPP_NAMESPACE
       exclusiveScissor = exclusiveScissor_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37542,6 +38172,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExtendedDynamicState2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37568,6 +38199,7 @@ namespace VULKAN_HPP_NAMESPACE
       extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37647,6 +38279,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExtendedDynamicStateFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37659,6 +38292,7 @@ namespace VULKAN_HPP_NAMESPACE
       extendedDynamicState = extendedDynamicState_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37734,6 +38368,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExternalBufferInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37758,6 +38393,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37833,6 +38469,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExternalFenceInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37845,6 +38482,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -37920,6 +38558,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExternalImageFormatInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -37932,6 +38571,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -38081,6 +38721,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExternalMemoryRDMAFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -38093,6 +38734,7 @@ namespace VULKAN_HPP_NAMESPACE
       externalMemoryRDMA = externalMemoryRDMA_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -38166,6 +38808,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceExternalSemaphoreInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -38178,6 +38821,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -38248,6 +38892,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFeatures2 & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -38260,6 +38905,7 @@ namespace VULKAN_HPP_NAMESPACE
       features = features_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -38474,6 +39120,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFragmentDensityMap2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -38486,6 +39133,7 @@ namespace VULKAN_HPP_NAMESPACE
       fragmentDensityMapDeferred = fragmentDensityMapDeferred_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -38650,6 +39298,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFragmentDensityMapFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -38676,6 +39325,7 @@ namespace VULKAN_HPP_NAMESPACE
       fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -38837,6 +39487,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -38849,6 +39500,7 @@ namespace VULKAN_HPP_NAMESPACE
       fragmentShaderBarycentric = fragmentShaderBarycentric_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -38928,6 +39580,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -38954,6 +39607,7 @@ namespace VULKAN_HPP_NAMESPACE
       fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -39037,6 +39691,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -39063,6 +39718,7 @@ namespace VULKAN_HPP_NAMESPACE
       noInvocationFragmentShadingRates = noInvocationFragmentShadingRates_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -39144,6 +39800,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFragmentShadingRateEnumsPropertiesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -39156,6 +39813,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxFragmentShadingRateInvocationCount = maxFragmentShadingRateInvocationCount_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -39236,6 +39894,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceFragmentShadingRateFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -39262,6 +39921,7 @@ namespace VULKAN_HPP_NAMESPACE
       attachmentFragmentShadingRate = attachmentFragmentShadingRate_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -39559,6 +40219,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceGlobalPriorityQueryFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -39571,6 +40232,7 @@ namespace VULKAN_HPP_NAMESPACE
       globalPriorityQuery = globalPriorityQuery_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -39720,6 +40382,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceHostQueryResetFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -39732,6 +40395,7 @@ namespace VULKAN_HPP_NAMESPACE
       hostQueryReset = hostQueryReset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -39907,6 +40571,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceImageDrmFormatModifierInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -39941,7 +40606,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PhysicalDeviceImageDrmFormatModifierInfoEXT & setQueueFamilyIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -39949,7 +40614,8 @@ namespace VULKAN_HPP_NAMESPACE
       pQueueFamilyIndices   = queueFamilyIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -40033,6 +40699,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceImageFormatInfo2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -40068,6 +40735,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -40147,6 +40815,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceImageRobustnessFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -40159,6 +40828,7 @@ namespace VULKAN_HPP_NAMESPACE
       robustImageAccess = robustImageAccess_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -40234,6 +40904,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceImageViewImageFormatInfoEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -40246,6 +40917,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageViewType = imageViewType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -40320,6 +40992,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceImagelessFramebufferFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -40332,6 +41005,7 @@ namespace VULKAN_HPP_NAMESPACE
       imagelessFramebuffer = imagelessFramebuffer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -40406,6 +41080,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceIndexTypeUint8FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -40418,6 +41093,7 @@ namespace VULKAN_HPP_NAMESPACE
       indexTypeUint8 = indexTypeUint8_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -40492,6 +41168,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceInheritedViewportScissorFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -40504,6 +41181,7 @@ namespace VULKAN_HPP_NAMESPACE
       inheritedViewportScissor2D = inheritedViewportScissor2D_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -40581,6 +41259,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceInlineUniformBlockFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -40600,6 +41279,7 @@ namespace VULKAN_HPP_NAMESPACE
       descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -41248,6 +41928,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceLineRasterizationFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -41295,6 +41976,7 @@ namespace VULKAN_HPP_NAMESPACE
       stippledSmoothLines = stippledSmoothLines_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -41602,6 +42284,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceMemoryPriorityFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -41614,6 +42297,7 @@ namespace VULKAN_HPP_NAMESPACE
       memoryPriority = memoryPriority_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -41824,6 +42508,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceMeshShaderFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -41841,6 +42526,7 @@ namespace VULKAN_HPP_NAMESPACE
       meshShader = meshShader_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -42033,6 +42719,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceMultiDrawFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -42044,6 +42731,7 @@ namespace VULKAN_HPP_NAMESPACE
       multiDraw = multiDraw_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -42186,6 +42874,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceMultiviewFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -42211,6 +42900,7 @@ namespace VULKAN_HPP_NAMESPACE
       multiviewTessellationShader = multiviewTessellationShader_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -42439,6 +43129,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -42451,6 +43142,7 @@ namespace VULKAN_HPP_NAMESPACE
       mutableDescriptorType = mutableDescriptorType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -42607,6 +43299,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevicePerformanceQueryFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -42626,6 +43319,7 @@ namespace VULKAN_HPP_NAMESPACE
       performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -42778,6 +43472,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevicePipelineCreationCacheControlFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -42790,6 +43485,7 @@ namespace VULKAN_HPP_NAMESPACE
       pipelineCreationCacheControl = pipelineCreationCacheControl_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -42866,6 +43562,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -42878,6 +43575,7 @@ namespace VULKAN_HPP_NAMESPACE
       pipelineExecutableInfo = pipelineExecutableInfo_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -43056,6 +43754,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevicePortabilitySubsetFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -43165,6 +43864,7 @@ namespace VULKAN_HPP_NAMESPACE
       vertexAttributeAccessBeyondStride = vertexAttributeAccessBeyondStride_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -43267,6 +43967,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevicePortabilitySubsetPropertiesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -43279,6 +43980,7 @@ namespace VULKAN_HPP_NAMESPACE
       minVertexInputBindingStrideAlignment = minVertexInputBindingStrideAlignment_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -43353,6 +44055,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDevicePrivateDataFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -43365,6 +44068,7 @@ namespace VULKAN_HPP_NAMESPACE
       privateData = privateData_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDevicePrivateDataFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -43662,6 +44366,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceProtectedMemoryFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -43674,6 +44379,7 @@ namespace VULKAN_HPP_NAMESPACE
       protectedMemory = protectedMemory_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -43821,6 +44527,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceProvokingVertexFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -43840,6 +44547,7 @@ namespace VULKAN_HPP_NAMESPACE
       transformFeedbackPreservesProvokingVertex = transformFeedbackPreservesProvokingVertex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -44065,6 +44773,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceRayQueryFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -44076,6 +44785,7 @@ namespace VULKAN_HPP_NAMESPACE
       rayQuery = rayQuery_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -44151,6 +44861,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceRayTracingMotionBlurFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -44170,6 +44881,7 @@ namespace VULKAN_HPP_NAMESPACE
       rayTracingMotionBlurPipelineTraceRaysIndirect = rayTracingMotionBlurPipelineTraceRaysIndirect_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -44254,6 +44966,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceRayTracingPipelineFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -44294,6 +45007,7 @@ namespace VULKAN_HPP_NAMESPACE
       rayTraversalPrimitiveCulling = rayTraversalPrimitiveCulling_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -44578,6 +45292,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -44590,6 +45305,7 @@ namespace VULKAN_HPP_NAMESPACE
       representativeFragmentTest = representativeFragmentTest_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -44667,6 +45383,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceRobustness2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -44693,6 +45410,7 @@ namespace VULKAN_HPP_NAMESPACE
       nullDescriptor = nullDescriptor_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45014,6 +45732,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceSamplerYcbcrConversionFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45026,6 +45745,7 @@ namespace VULKAN_HPP_NAMESPACE
       samplerYcbcrConversion = samplerYcbcrConversion_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45100,6 +45820,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceScalarBlockLayoutFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45112,6 +45833,7 @@ namespace VULKAN_HPP_NAMESPACE
       scalarBlockLayout = scalarBlockLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45188,6 +45910,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceSeparateDepthStencilLayoutsFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45200,6 +45923,7 @@ namespace VULKAN_HPP_NAMESPACE
       separateDepthStencilLayouts = separateDepthStencilLayouts_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45298,6 +46022,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderAtomicFloatFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45387,6 +46112,7 @@ namespace VULKAN_HPP_NAMESPACE
       sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45485,6 +46211,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderAtomicInt64Features & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45504,6 +46231,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderSharedInt64Atomics = shaderSharedInt64Atomics_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45582,6 +46310,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderClockFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45601,6 +46330,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderDeviceClock = shaderDeviceClock_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45870,6 +46600,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45882,6 +46613,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -45957,6 +46689,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderDrawParametersFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -45969,6 +46702,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderDrawParameters = shaderDrawParameters_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46045,6 +46779,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderFloat16Int8Features & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46064,6 +46799,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderInt8 = shaderInt8_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46144,6 +46880,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46163,6 +46900,7 @@ namespace VULKAN_HPP_NAMESPACE
       sparseImageInt64Atomics = sparseImageInt64Atomics_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46239,6 +46977,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderImageFootprintFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46251,6 +46990,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageFootprint = imageFootprint_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46326,6 +47066,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46338,6 +47079,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderIntegerFunctions2 = shaderIntegerFunctions2_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46412,6 +47154,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderSMBuiltinsFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46424,6 +47167,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderSMBuiltins = shaderSMBuiltins_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46576,6 +47320,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderSubgroupExtendedTypesFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46588,6 +47333,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46666,6 +47412,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46678,6 +47425,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderSubgroupUniformControlFlow = shaderSubgroupUniformControlFlow_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46755,6 +47503,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShaderTerminateInvocationFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46767,6 +47516,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderTerminateInvocation = shaderTerminateInvocation_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -46844,6 +47594,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceShadingRateImageFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -46863,6 +47614,7 @@ namespace VULKAN_HPP_NAMESPACE
       shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47026,6 +47778,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceSparseImageFormatInfo2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47062,6 +47815,7 @@ namespace VULKAN_HPP_NAMESPACE
       tiling = tiling_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47222,6 +47976,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceSubgroupSizeControlFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47241,6 +47996,7 @@ namespace VULKAN_HPP_NAMESPACE
       computeFullSubgroups = computeFullSubgroups_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47401,6 +48157,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceSubpassShadingFeaturesHUAWEI & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47413,6 +48170,7 @@ namespace VULKAN_HPP_NAMESPACE
       subpassShading = subpassShading_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47557,6 +48315,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceSurfaceInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47568,6 +48327,7 @@ namespace VULKAN_HPP_NAMESPACE
       surface = surface_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47640,6 +48400,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceSynchronization2FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47652,6 +48413,7 @@ namespace VULKAN_HPP_NAMESPACE
       synchronization2 = synchronization2_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceSynchronization2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47726,6 +48488,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47738,6 +48501,7 @@ namespace VULKAN_HPP_NAMESPACE
       texelBufferAlignment = texelBufferAlignment_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47899,6 +48663,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47911,6 +48676,7 @@ namespace VULKAN_HPP_NAMESPACE
       textureCompressionASTC_HDR = textureCompressionASTC_HDR_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -47984,6 +48750,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceTimelineSemaphoreFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -47996,6 +48763,7 @@ namespace VULKAN_HPP_NAMESPACE
       timelineSemaphore = timelineSemaphore_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -48228,6 +48996,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceTransformFeedbackFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -48247,6 +49016,7 @@ namespace VULKAN_HPP_NAMESPACE
       geometryStreams = geometryStreams_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -48434,6 +49204,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceUniformBufferStandardLayoutFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -48446,6 +49217,7 @@ namespace VULKAN_HPP_NAMESPACE
       uniformBufferStandardLayout = uniformBufferStandardLayout_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -48523,6 +49295,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceVariablePointersFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -48542,6 +49315,7 @@ namespace VULKAN_HPP_NAMESPACE
       variablePointers = variablePointers_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -48623,6 +49397,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -48642,6 +49417,7 @@ namespace VULKAN_HPP_NAMESPACE
       vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -48794,6 +49570,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceVertexInputDynamicStateFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -48806,6 +49583,7 @@ namespace VULKAN_HPP_NAMESPACE
       vertexInputDynamicState = vertexInputDynamicState_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -48883,6 +49661,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoProfileKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -48916,6 +49695,7 @@ namespace VULKAN_HPP_NAMESPACE
       chromaBitDepth = chromaBitDepth_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoProfileKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -48991,6 +49771,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoProfilesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -49008,6 +49789,7 @@ namespace VULKAN_HPP_NAMESPACE
       pProfiles = pProfiles_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoProfilesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -49175,6 +49957,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceVulkan11Features & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -49263,6 +50046,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderDrawParameters = shaderDrawParameters_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -49567,6 +50351,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceVulkan12Features & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -49899,6 +50684,7 @@ namespace VULKAN_HPP_NAMESPACE
       subgroupBroadcastDynamicId = subgroupBroadcastDynamicId_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -50356,6 +51142,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceVulkanMemoryModelFeatures & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -50382,6 +51169,7 @@ namespace VULKAN_HPP_NAMESPACE
       vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -50468,6 +51256,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -50501,6 +51290,7 @@ namespace VULKAN_HPP_NAMESPACE
       workgroupMemoryExplicitLayout16BitAccess = workgroupMemoryExplicitLayout16BitAccess_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -50582,6 +51372,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -50594,6 +51385,7 @@ namespace VULKAN_HPP_NAMESPACE
       ycbcr2plane444Formats = ycbcr2plane444Formats_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -50667,6 +51459,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceYcbcrImageArraysFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -50679,6 +51472,7 @@ namespace VULKAN_HPP_NAMESPACE
       ycbcrImageArrays = ycbcrImageArrays_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -50754,6 +51548,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -50766,6 +51561,7 @@ namespace VULKAN_HPP_NAMESPACE
       shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -50847,6 +51643,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineCacheCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -50871,7 +51668,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     template <typename T>
     PipelineCacheCreateInfo &
       setInitialData( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const T> const & initialData_ ) VULKAN_HPP_NOEXCEPT
@@ -50880,7 +51677,8 @@ namespace VULKAN_HPP_NAMESPACE
       pInitialData    = initialData_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -50958,6 +51756,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineCacheHeaderVersionOne & setHeaderSize( uint32_t headerSize_ ) VULKAN_HPP_NOEXCEPT
     {
       headerSize = headerSize_;
@@ -50989,6 +51788,7 @@ namespace VULKAN_HPP_NAMESPACE
       pipelineCacheUUID = pipelineCacheUUID_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51066,6 +51866,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineColorBlendAdvancedStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51092,6 +51893,7 @@ namespace VULKAN_HPP_NAMESPACE
       blendOverlap = blendOverlap_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51175,6 +51977,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineColorWriteCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51194,7 +51997,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineColorWriteCreateInfoEXT & setColorWriteEnables(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables_ )
       VULKAN_HPP_NOEXCEPT
@@ -51203,7 +52006,8 @@ namespace VULKAN_HPP_NAMESPACE
       pColorWriteEnables = colorWriteEnables_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51277,6 +52081,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineCompilerControlCreateInfoAMD & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51289,6 +52094,7 @@ namespace VULKAN_HPP_NAMESPACE
       compilerControlFlags = compilerControlFlags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51385,6 +52191,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineCoverageModulationStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51426,7 +52233,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTable(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const float> const & coverageModulationTable_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -51434,7 +52241,8 @@ namespace VULKAN_HPP_NAMESPACE
       pCoverageModulationTable     = coverageModulationTable_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51521,6 +52329,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineCoverageReductionStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51540,6 +52349,7 @@ namespace VULKAN_HPP_NAMESPACE
       coverageReductionMode = coverageReductionMode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51621,6 +52431,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineCoverageToColorStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51647,6 +52458,7 @@ namespace VULKAN_HPP_NAMESPACE
       coverageToColorLocation = coverageToColorLocation_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51799,6 +52611,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineCreationFeedbackCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51826,7 +52639,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineCreationFeedbackCreateInfoEXT & setPipelineStageCreationFeedbacks(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT> const &
         pipelineStageCreationFeedbacks_ ) VULKAN_HPP_NOEXCEPT
@@ -51835,7 +52648,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPipelineStageCreationFeedbacks    = pipelineStageCreationFeedbacks_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -51933,6 +52747,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineDiscardRectangleStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -51967,7 +52782,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangles(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles_ )
       VULKAN_HPP_NOEXCEPT
@@ -51976,7 +52791,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDiscardRectangles    = discardRectangles_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -52054,6 +52870,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineExecutableInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -52071,6 +52888,7 @@ namespace VULKAN_HPP_NAMESPACE
       executableIndex = executableIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -52295,6 +53113,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   union PipelineExecutableStatisticValueKHR
   {
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
     PipelineExecutableStatisticValueKHR( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const & rhs )
       VULKAN_HPP_NOEXCEPT
     {
@@ -52308,7 +53127,9 @@ namespace VULKAN_HPP_NAMESPACE
     PipelineExecutableStatisticValueKHR( uint64_t u64_ ) : u64( u64_ ) {}
 
     PipelineExecutableStatisticValueKHR( double f64_ ) : f64( f64_ ) {}
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
     PipelineExecutableStatisticValueKHR & setB32( VULKAN_HPP_NAMESPACE::Bool32 b32_ ) VULKAN_HPP_NOEXCEPT
     {
       b32 = b32_;
@@ -52332,6 +53153,7 @@ namespace VULKAN_HPP_NAMESPACE
       f64 = f64_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR &
       operator=( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -52467,6 +53289,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineFragmentShadingRateEnumStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -52493,6 +53316,7 @@ namespace VULKAN_HPP_NAMESPACE
       combinerOps = combinerOps_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -52576,6 +53400,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineFragmentShadingRateStateCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -52595,6 +53420,7 @@ namespace VULKAN_HPP_NAMESPACE
       combinerOps = combinerOps_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -52664,6 +53490,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -52675,6 +53502,7 @@ namespace VULKAN_HPP_NAMESPACE
       pipeline = pipeline_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -52741,6 +53569,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PushConstantRange & setStageFlags( VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags_ ) VULKAN_HPP_NOEXCEPT
     {
       stageFlags = stageFlags_;
@@ -52758,6 +53587,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -52842,6 +53672,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineLayoutCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -52867,7 +53698,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineLayoutCreateInfo & setSetLayouts(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const &
         setLayouts_ ) VULKAN_HPP_NOEXCEPT
@@ -52876,7 +53707,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSetLayouts    = setLayouts_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     PipelineLayoutCreateInfo & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -52891,7 +53722,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineLayoutCreateInfo & setPushConstantRanges(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PushConstantRange> const &
         pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT
@@ -52900,7 +53731,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPushConstantRanges    = pushConstantRanges_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -52985,6 +53817,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineLibraryCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53004,7 +53837,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineLibraryCreateInfoKHR & setLibraries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Pipeline> const & libraries_ )
       VULKAN_HPP_NOEXCEPT
@@ -53013,7 +53846,8 @@ namespace VULKAN_HPP_NAMESPACE
       pLibraries   = libraries_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53095,6 +53929,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRasterizationConservativeStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53121,6 +53956,7 @@ namespace VULKAN_HPP_NAMESPACE
       extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53202,6 +54038,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRasterizationDepthClipStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53221,6 +54058,7 @@ namespace VULKAN_HPP_NAMESPACE
       depthClipEnable = depthClipEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53304,6 +54142,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRasterizationLineStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53337,6 +54176,7 @@ namespace VULKAN_HPP_NAMESPACE
       lineStipplePattern = lineStipplePattern_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53420,6 +54260,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRasterizationProvokingVertexStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53432,6 +54273,7 @@ namespace VULKAN_HPP_NAMESPACE
       provokingVertexMode = provokingVertexMode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53508,6 +54350,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRasterizationStateRasterizationOrderAMD & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53520,6 +54363,7 @@ namespace VULKAN_HPP_NAMESPACE
       rasterizationOrder = rasterizationOrder_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53597,6 +54441,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRasterizationStateStreamCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53616,6 +54461,7 @@ namespace VULKAN_HPP_NAMESPACE
       rasterizationStream = rasterizationStream_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53693,6 +54539,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineRepresentativeFragmentTestStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53705,6 +54552,7 @@ namespace VULKAN_HPP_NAMESPACE
       representativeFragmentTestEnable = representativeFragmentTestEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53782,6 +54630,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineSampleLocationsStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53801,6 +54650,7 @@ namespace VULKAN_HPP_NAMESPACE
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -53952,6 +54802,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineTessellationDomainOriginStateCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -53964,6 +54815,7 @@ namespace VULKAN_HPP_NAMESPACE
       domainOrigin = domainOrigin_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54036,6 +54888,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VertexInputBindingDivisorDescriptionEXT & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
     {
       binding = binding_;
@@ -54047,6 +54900,7 @@ namespace VULKAN_HPP_NAMESPACE
       divisor = divisor_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVertexInputBindingDivisorDescriptionEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54126,6 +54980,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineVertexInputDivisorStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -54147,7 +55002,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineVertexInputDivisorStateCreateInfoEXT & setVertexBindingDivisors(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
         const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT> const & vertexBindingDivisors_ )
@@ -54157,7 +55012,8 @@ namespace VULKAN_HPP_NAMESPACE
       pVertexBindingDivisors    = vertexBindingDivisors_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineVertexInputDivisorStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54252,6 +55108,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -54279,7 +55136,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineViewportCoarseSampleOrderStateCreateInfoNV & setCustomSampleOrders(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const &
         customSampleOrders_ ) VULKAN_HPP_NOEXCEPT
@@ -54288,7 +55145,8 @@ namespace VULKAN_HPP_NAMESPACE
       pCustomSampleOrders    = customSampleOrders_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54379,6 +55237,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineViewportExclusiveScissorStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -54399,7 +55258,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineViewportExclusiveScissorStateCreateInfoNV & setExclusiveScissors(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors_ )
       VULKAN_HPP_NOEXCEPT
@@ -54408,7 +55267,8 @@ namespace VULKAN_HPP_NAMESPACE
       pExclusiveScissors    = exclusiveScissors_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54488,6 +55348,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ShadingRatePaletteNV & setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ ) VULKAN_HPP_NOEXCEPT
     {
       shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_;
@@ -54501,7 +55362,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ShadingRatePaletteNV & setShadingRatePaletteEntries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV> const &
         shadingRatePaletteEntries_ ) VULKAN_HPP_NOEXCEPT
@@ -54510,7 +55371,8 @@ namespace VULKAN_HPP_NAMESPACE
       pShadingRatePaletteEntries   = shadingRatePaletteEntries_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54593,6 +55455,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineViewportShadingRateImageStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -54619,7 +55482,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRatePalettes(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const &
         shadingRatePalettes_ ) VULKAN_HPP_NOEXCEPT
@@ -54628,7 +55491,8 @@ namespace VULKAN_HPP_NAMESPACE
       pShadingRatePalettes = shadingRatePalettes_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54709,6 +55573,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ViewportSwizzleNV & setX( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -54732,6 +55597,7 @@ namespace VULKAN_HPP_NAMESPACE
       w = w_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54814,6 +55680,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineViewportSwizzleStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -54840,7 +55707,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineViewportSwizzleStateCreateInfoNV & setViewportSwizzles(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const &
         viewportSwizzles_ ) VULKAN_HPP_NOEXCEPT
@@ -54849,7 +55716,8 @@ namespace VULKAN_HPP_NAMESPACE
       pViewportSwizzles = viewportSwizzles_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -54919,6 +55787,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ViewportWScalingNV & setXcoeff( float xcoeff_ ) VULKAN_HPP_NOEXCEPT
     {
       xcoeff = xcoeff_;
@@ -54930,6 +55799,7 @@ namespace VULKAN_HPP_NAMESPACE
       ycoeff = ycoeff_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55010,6 +55880,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PipelineViewportWScalingStateCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -55036,7 +55907,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PipelineViewportWScalingStateCreateInfoNV & setViewportWScalings(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const &
         viewportWScalings_ ) VULKAN_HPP_NOEXCEPT
@@ -55045,7 +55916,8 @@ namespace VULKAN_HPP_NAMESPACE
       pViewportWScalings = viewportWScalings_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55119,6 +55991,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PresentFrameTokenGGP & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -55130,6 +56003,7 @@ namespace VULKAN_HPP_NAMESPACE
       frameToken = frameToken_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55246,6 +56120,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PresentInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -55264,7 +56139,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PresentInfoKHR & setWaitSemaphores(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Semaphore> const & waitSemaphores_ )
       VULKAN_HPP_NOEXCEPT
@@ -55273,7 +56148,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitSemaphores    = waitSemaphores_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     PresentInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -55287,7 +56162,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PresentInfoKHR & setSwapchains(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains_ )
       VULKAN_HPP_NOEXCEPT
@@ -55296,7 +56171,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSwapchains    = swapchains_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     PresentInfoKHR & setPImageIndices( const uint32_t * pImageIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -55304,7 +56179,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PresentInfoKHR & setImageIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & imageIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -55312,7 +56187,7 @@ namespace VULKAN_HPP_NAMESPACE
       pImageIndices  = imageIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     PresentInfoKHR & setPResults( VULKAN_HPP_NAMESPACE::Result * pResults_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -55320,7 +56195,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PresentInfoKHR & setResults(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<VULKAN_HPP_NAMESPACE::Result> const & results_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -55328,7 +56203,8 @@ namespace VULKAN_HPP_NAMESPACE
       pResults       = results_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55406,6 +56282,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RectLayerKHR & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT
     {
       offset = offset_;
@@ -55423,6 +56300,7 @@ namespace VULKAN_HPP_NAMESPACE
       layer = layer_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55488,6 +56366,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PresentRegionKHR & setRectangleCount( uint32_t rectangleCount_ ) VULKAN_HPP_NOEXCEPT
     {
       rectangleCount = rectangleCount_;
@@ -55500,7 +56379,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PresentRegionKHR & setRectangles(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::RectLayerKHR> const & rectangles_ )
       VULKAN_HPP_NOEXCEPT
@@ -55509,7 +56388,8 @@ namespace VULKAN_HPP_NAMESPACE
       pRectangles    = rectangles_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55579,6 +56459,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PresentRegionsKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -55597,7 +56478,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PresentRegionsKHR & setRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PresentRegionKHR> const & regions_ )
       VULKAN_HPP_NOEXCEPT
@@ -55606,7 +56487,8 @@ namespace VULKAN_HPP_NAMESPACE
       pRegions       = regions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55674,6 +56556,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PresentTimeGOOGLE & setPresentID( uint32_t presentID_ ) VULKAN_HPP_NOEXCEPT
     {
       presentID = presentID_;
@@ -55685,6 +56568,7 @@ namespace VULKAN_HPP_NAMESPACE
       desiredPresentTime = desiredPresentTime_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55754,6 +56638,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PresentTimesInfoGOOGLE & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -55772,7 +56657,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     PresentTimesInfoGOOGLE & setTimes(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE> const & times_ )
       VULKAN_HPP_NOEXCEPT
@@ -55781,7 +56666,8 @@ namespace VULKAN_HPP_NAMESPACE
       pTimes         = times_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55851,6 +56737,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     PrivateDataSlotCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -55863,6 +56750,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkPrivateDataSlotCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -55930,6 +56818,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ProtectedSubmitInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -55941,6 +56830,7 @@ namespace VULKAN_HPP_NAMESPACE
       protectedSubmit = protectedSubmit_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -56014,6 +56904,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     QueryPoolCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -56044,6 +56935,7 @@ namespace VULKAN_HPP_NAMESPACE
       pipelineStatistics = pipelineStatistics_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -56131,6 +57023,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     QueryPoolPerformanceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -56155,7 +57048,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     QueryPoolPerformanceCreateInfoKHR & setCounterIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & counterIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -56163,7 +57056,8 @@ namespace VULKAN_HPP_NAMESPACE
       pCounterIndices   = counterIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -56241,6 +57135,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     QueryPoolPerformanceQueryCreateInfoINTEL & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -56253,6 +57148,7 @@ namespace VULKAN_HPP_NAMESPACE
       performanceCountersSampling = performanceCountersSampling_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -56488,6 +57384,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     QueueFamilyGlobalPriorityPropertiesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -56507,6 +57404,7 @@ namespace VULKAN_HPP_NAMESPACE
       priorities = priorities_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkQueueFamilyGlobalPriorityPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -56725,6 +57623,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RayTracingShaderGroupCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -56768,6 +57667,7 @@ namespace VULKAN_HPP_NAMESPACE
       pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -56852,6 +57752,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RayTracingPipelineInterfaceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -56871,6 +57772,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxPipelineRayHitAttributeSize = maxPipelineRayHitAttributeSize_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -56995,6 +57897,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RayTracingPipelineCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -57020,7 +57923,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RayTracingPipelineCreateInfoKHR & setStages(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> const &
         stages_ ) VULKAN_HPP_NOEXCEPT
@@ -57029,7 +57932,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStages    = stages_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RayTracingPipelineCreateInfoKHR & setGroupCount( uint32_t groupCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -57044,7 +57947,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RayTracingPipelineCreateInfoKHR &
       setGroups( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
                  const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR> const & groups_ ) VULKAN_HPP_NOEXCEPT
@@ -57053,7 +57956,7 @@ namespace VULKAN_HPP_NAMESPACE
       pGroups    = groups_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RayTracingPipelineCreateInfoKHR &
       setMaxPipelineRayRecursionDepth( uint32_t maxPipelineRayRecursionDepth_ ) VULKAN_HPP_NOEXCEPT
@@ -57101,6 +58004,7 @@ namespace VULKAN_HPP_NAMESPACE
       basePipelineIndex = basePipelineIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -57196,6 +58100,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RayTracingShaderGroupCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -57232,6 +58137,7 @@ namespace VULKAN_HPP_NAMESPACE
       intersectionShader = intersectionShader_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -57347,6 +58253,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RayTracingPipelineCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -57372,7 +58279,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RayTracingPipelineCreateInfoNV & setStages(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> const &
         stages_ ) VULKAN_HPP_NOEXCEPT
@@ -57381,7 +58288,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStages    = stages_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RayTracingPipelineCreateInfoNV & setGroupCount( uint32_t groupCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -57396,7 +58303,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RayTracingPipelineCreateInfoNV &
       setGroups( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
                  const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV> const & groups_ ) VULKAN_HPP_NOEXCEPT
@@ -57405,7 +58312,7 @@ namespace VULKAN_HPP_NAMESPACE
       pGroups    = groups_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RayTracingPipelineCreateInfoNV & setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -57431,6 +58338,7 @@ namespace VULKAN_HPP_NAMESPACE
       basePipelineIndex = basePipelineIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -57576,6 +58484,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassAttachmentBeginInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -57595,7 +58504,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassAttachmentBeginInfo & setAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ImageView> const & attachments_ )
       VULKAN_HPP_NOEXCEPT
@@ -57604,7 +58513,8 @@ namespace VULKAN_HPP_NAMESPACE
       pAttachments    = attachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -57698,6 +58608,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassBeginInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -57734,7 +58645,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassBeginInfo & setClearValues(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ClearValue> const & clearValues_ )
       VULKAN_HPP_NOEXCEPT
@@ -57743,7 +58654,8 @@ namespace VULKAN_HPP_NAMESPACE
       pClearValues    = clearValues_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -57868,6 +58780,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassDescription & setFlags( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ ) VULKAN_HPP_NOEXCEPT
     {
       flags = flags_;
@@ -57894,7 +58807,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription & setInputAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentReference> const &
         inputAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -57903,7 +58816,7 @@ namespace VULKAN_HPP_NAMESPACE
       pInputAttachments    = inputAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubpassDescription & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -57918,7 +58831,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription & setColorAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentReference> const &
         colorAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -57927,7 +58840,7 @@ namespace VULKAN_HPP_NAMESPACE
       pColorAttachments    = colorAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubpassDescription & setPResolveAttachments(
       const VULKAN_HPP_NAMESPACE::AttachmentReference * pResolveAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -57936,7 +58849,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription & setResolveAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentReference> const &
         resolveAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -57945,7 +58858,7 @@ namespace VULKAN_HPP_NAMESPACE
       pResolveAttachments  = resolveAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubpassDescription & setPDepthStencilAttachment(
       const VULKAN_HPP_NAMESPACE::AttachmentReference * pDepthStencilAttachment_ ) VULKAN_HPP_NOEXCEPT
@@ -57966,7 +58879,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription & setPreserveAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & preserveAttachments_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -57974,7 +58887,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPreserveAttachments    = preserveAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -58058,6 +58972,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassDependency & setSrcSubpass( uint32_t srcSubpass_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubpass = srcSubpass_;
@@ -58099,6 +59014,7 @@ namespace VULKAN_HPP_NAMESPACE
       dependencyFlags = dependencyFlags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -58198,6 +59114,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -58223,7 +59140,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassCreateInfo & setAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentDescription> const &
         attachments_ ) VULKAN_HPP_NOEXCEPT
@@ -58232,7 +59149,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAttachments    = attachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassCreateInfo & setSubpassCount( uint32_t subpassCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58247,7 +59164,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassCreateInfo & setSubpasses(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SubpassDescription> const & subpasses_ )
       VULKAN_HPP_NOEXCEPT
@@ -58256,7 +59173,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSubpasses   = subpasses_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58271,7 +59188,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassCreateInfo & setDependencies(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SubpassDependency> const &
         dependencies_ ) VULKAN_HPP_NOEXCEPT
@@ -58280,7 +59197,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDependencies   = dependencies_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -58415,6 +59333,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassDescription2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -58453,7 +59372,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription2 & setInputAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentReference2> const &
         inputAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -58462,7 +59381,7 @@ namespace VULKAN_HPP_NAMESPACE
       pInputAttachments    = inputAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubpassDescription2 & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58477,7 +59396,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription2 & setColorAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentReference2> const &
         colorAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -58486,7 +59405,7 @@ namespace VULKAN_HPP_NAMESPACE
       pColorAttachments    = colorAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubpassDescription2 & setPResolveAttachments(
       const VULKAN_HPP_NAMESPACE::AttachmentReference2 * pResolveAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -58495,7 +59414,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription2 & setResolveAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentReference2> const &
         resolveAttachments_ ) VULKAN_HPP_NOEXCEPT
@@ -58504,7 +59423,7 @@ namespace VULKAN_HPP_NAMESPACE
       pResolveAttachments  = resolveAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubpassDescription2 & setPDepthStencilAttachment(
       const VULKAN_HPP_NAMESPACE::AttachmentReference2 * pDepthStencilAttachment_ ) VULKAN_HPP_NOEXCEPT
@@ -58525,7 +59444,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubpassDescription2 & setPreserveAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & preserveAttachments_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58533,7 +59452,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPreserveAttachments    = preserveAttachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -58632,6 +59552,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassDependency2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -58686,6 +59607,7 @@ namespace VULKAN_HPP_NAMESPACE
       viewOffset = viewOffset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -58802,6 +59724,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassCreateInfo2 & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -58827,7 +59750,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassCreateInfo2 & setAttachments(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentDescription2> const &
         attachments_ ) VULKAN_HPP_NOEXCEPT
@@ -58836,7 +59759,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAttachments    = attachments_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassCreateInfo2 & setSubpassCount( uint32_t subpassCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58851,7 +59774,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassCreateInfo2 & setSubpasses(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SubpassDescription2> const &
         subpasses_ ) VULKAN_HPP_NOEXCEPT
@@ -58860,7 +59783,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSubpasses   = subpasses_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassCreateInfo2 & setDependencyCount( uint32_t dependencyCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58875,7 +59798,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassCreateInfo2 & setDependencies(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SubpassDependency2> const &
         dependencies_ ) VULKAN_HPP_NOEXCEPT
@@ -58884,7 +59807,7 @@ namespace VULKAN_HPP_NAMESPACE
       pDependencies   = dependencies_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassCreateInfo2 & setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58898,7 +59821,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassCreateInfo2 & setCorrelatedViewMasks(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & correlatedViewMasks_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -58906,7 +59829,8 @@ namespace VULKAN_HPP_NAMESPACE
       pCorrelatedViewMasks    = correlatedViewMasks_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -58993,6 +59917,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassFragmentDensityMapCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -59005,6 +59930,7 @@ namespace VULKAN_HPP_NAMESPACE
       fragmentDensityMapAttachment = fragmentDensityMapAttachment_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -59091,6 +60017,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassInputAttachmentAspectCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -59111,7 +60038,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassInputAttachmentAspectCreateInfo & setAspectReferences(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference> const &
         aspectReferences_ ) VULKAN_HPP_NOEXCEPT
@@ -59120,7 +60047,8 @@ namespace VULKAN_HPP_NAMESPACE
       pAspectReferences    = aspectReferences_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -59217,6 +60145,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassMultiviewCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -59235,7 +60164,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassMultiviewCreateInfo & setViewMasks(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & viewMasks_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -59243,7 +60172,7 @@ namespace VULKAN_HPP_NAMESPACE
       pViewMasks   = viewMasks_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassMultiviewCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -59257,7 +60186,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassMultiviewCreateInfo & setViewOffsets(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const int32_t> const & viewOffsets_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -59265,7 +60194,7 @@ namespace VULKAN_HPP_NAMESPACE
       pViewOffsets    = viewOffsets_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassMultiviewCreateInfo & setCorrelationMaskCount( uint32_t correlationMaskCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -59279,7 +60208,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassMultiviewCreateInfo & setCorrelationMasks(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & correlationMasks_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -59287,7 +60216,8 @@ namespace VULKAN_HPP_NAMESPACE
       pCorrelationMasks    = correlationMasks_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -59365,6 +60295,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassSampleLocationsEXT & setSubpassIndex( uint32_t subpassIndex_ ) VULKAN_HPP_NOEXCEPT
     {
       subpassIndex = subpassIndex_;
@@ -59377,6 +60308,7 @@ namespace VULKAN_HPP_NAMESPACE
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -59461,6 +60393,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassSampleLocationsBeginInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -59482,7 +60415,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassSampleLocationsBeginInfoEXT & setAttachmentInitialSampleLocations(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT> const &
         attachmentInitialSampleLocations_ ) VULKAN_HPP_NOEXCEPT
@@ -59491,7 +60424,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAttachmentInitialSampleLocations     = attachmentInitialSampleLocations_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     RenderPassSampleLocationsBeginInfoEXT &
       setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) VULKAN_HPP_NOEXCEPT
@@ -59507,7 +60440,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     RenderPassSampleLocationsBeginInfoEXT & setPostSubpassSampleLocations(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT> const &
         postSubpassSampleLocations_ ) VULKAN_HPP_NOEXCEPT
@@ -59516,7 +60449,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPostSubpassSampleLocations     = postSubpassSampleLocations_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -59593,6 +60527,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     RenderPassTransformBeginInfoQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -59605,6 +60540,7 @@ namespace VULKAN_HPP_NAMESPACE
       transform = transform_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -59700,6 +60636,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ResolveImageInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -59742,7 +60679,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ResolveImageInfo2KHR & setRegions(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ImageResolve2KHR> const & regions_ )
       VULKAN_HPP_NOEXCEPT
@@ -59751,7 +60688,8 @@ namespace VULKAN_HPP_NAMESPACE
       pRegions    = regions_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkResolveImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -59857,6 +60795,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SamplerCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -59959,6 +60898,7 @@ namespace VULKAN_HPP_NAMESPACE
       unnormalizedCoordinates = unnormalizedCoordinates_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60054,6 +60994,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SamplerCustomBorderColorCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60072,6 +61013,7 @@ namespace VULKAN_HPP_NAMESPACE
       format = format_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60129,6 +61071,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SamplerReductionModeCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60141,6 +61084,7 @@ namespace VULKAN_HPP_NAMESPACE
       reductionMode = reductionMode_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60227,6 +61171,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SamplerYcbcrConversionCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60286,6 +61231,7 @@ namespace VULKAN_HPP_NAMESPACE
       forceExplicitReconstruction = forceExplicitReconstruction_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60442,6 +61388,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SamplerYcbcrConversionInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60454,6 +61401,7 @@ namespace VULKAN_HPP_NAMESPACE
       conversion = conversion_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60528,6 +61476,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ScreenSurfaceCreateInfoQNX & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60552,6 +61501,7 @@ namespace VULKAN_HPP_NAMESPACE
       window = window_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60624,6 +61574,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60635,6 +61586,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60705,6 +61657,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreGetFdInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60723,6 +61676,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60798,6 +61752,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60816,6 +61771,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60895,6 +61851,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreGetZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -60913,6 +61870,7 @@ namespace VULKAN_HPP_NAMESPACE
       handleType = handleType_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -60986,6 +61944,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreSignalInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -61003,6 +61962,7 @@ namespace VULKAN_HPP_NAMESPACE
       value = value_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -61078,6 +62038,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreSubmitInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -61107,6 +62068,7 @@ namespace VULKAN_HPP_NAMESPACE
       deviceIndex = deviceIndex_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -61180,6 +62142,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreTypeCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -61197,6 +62160,7 @@ namespace VULKAN_HPP_NAMESPACE
       initialValue = initialValue_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -61294,6 +62258,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SemaphoreWaitInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -61318,7 +62283,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SemaphoreWaitInfo & setSemaphores(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Semaphore> const & semaphores_ )
       VULKAN_HPP_NOEXCEPT
@@ -61327,7 +62292,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSemaphores    = semaphores_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SemaphoreWaitInfo & setPValues( const uint64_t * pValues_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -61335,7 +62300,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SemaphoreWaitInfo &
       setValues( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & values_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -61343,7 +62308,8 @@ namespace VULKAN_HPP_NAMESPACE
       pValues        = values_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -61412,11 +62378,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SetStateFlagsIndirectCommandNV & setData( uint32_t data_ ) VULKAN_HPP_NOEXCEPT
     {
       data = data_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -61487,6 +62455,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ShaderModuleCreateInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -61511,7 +62480,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ShaderModuleCreateInfo &
       setCode( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & code_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -61519,7 +62488,8 @@ namespace VULKAN_HPP_NAMESPACE
       pCode    = code_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -61595,6 +62565,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ShaderModuleValidationCacheCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -61607,6 +62578,7 @@ namespace VULKAN_HPP_NAMESPACE
       validationCache = validationCache_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -62171,6 +63143,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     StreamDescriptorSurfaceCreateInfoGGP & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -62190,6 +63163,7 @@ namespace VULKAN_HPP_NAMESPACE
       streamDescriptor = streamDescriptor_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -62263,6 +63237,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     StridedDeviceAddressRegionKHR &
       setDeviceAddress( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -62281,6 +63256,7 @@ namespace VULKAN_HPP_NAMESPACE
       size = size_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -62383,6 +63359,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubmitInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -62401,7 +63378,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubmitInfo & setWaitSemaphores(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Semaphore> const & waitSemaphores_ )
       VULKAN_HPP_NOEXCEPT
@@ -62410,7 +63387,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitSemaphores    = waitSemaphores_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubmitInfo &
       setPWaitDstStageMask( const VULKAN_HPP_NAMESPACE::PipelineStageFlags * pWaitDstStageMask_ ) VULKAN_HPP_NOEXCEPT
@@ -62419,7 +63396,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubmitInfo & setWaitDstStageMask(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PipelineStageFlags> const &
         waitDstStageMask_ ) VULKAN_HPP_NOEXCEPT
@@ -62428,7 +63405,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitDstStageMask  = waitDstStageMask_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -62442,7 +63419,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubmitInfo & setCommandBuffers(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers_ )
       VULKAN_HPP_NOEXCEPT
@@ -62451,7 +63428,7 @@ namespace VULKAN_HPP_NAMESPACE
       pCommandBuffers    = commandBuffers_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -62465,7 +63442,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubmitInfo & setSignalSemaphores(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Semaphore> const & signalSemaphores_ )
       VULKAN_HPP_NOEXCEPT
@@ -62474,7 +63451,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSignalSemaphores    = signalSemaphores_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -62580,6 +63558,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubmitInfo2KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -62605,7 +63584,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubmitInfo2KHR & setWaitSemaphoreInfos(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR> const &
         waitSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT
@@ -62614,7 +63593,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitSemaphoreInfos    = waitSemaphoreInfos_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubmitInfo2KHR & setCommandBufferInfoCount( uint32_t commandBufferInfoCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -62629,7 +63608,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubmitInfo2KHR & setCommandBufferInfos(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR> const &
         commandBufferInfos_ ) VULKAN_HPP_NOEXCEPT
@@ -62638,7 +63617,7 @@ namespace VULKAN_HPP_NAMESPACE
       pCommandBufferInfos    = commandBufferInfos_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SubmitInfo2KHR & setSignalSemaphoreInfoCount( uint32_t signalSemaphoreInfoCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -62653,7 +63632,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SubmitInfo2KHR & setSignalSemaphoreInfos(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR> const &
         signalSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT
@@ -62662,7 +63641,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSignalSemaphoreInfos    = signalSemaphoreInfos_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubmitInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -62740,6 +63720,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassBeginInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -62751,6 +63732,7 @@ namespace VULKAN_HPP_NAMESPACE
       contents = contents_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -62827,6 +63809,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassDescriptionDepthStencilResolve & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -62853,6 +63836,7 @@ namespace VULKAN_HPP_NAMESPACE
       pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -62922,11 +63906,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SubpassEndInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -63333,6 +64319,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SurfaceCapabilitiesFullScreenExclusiveEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -63345,6 +64332,7 @@ namespace VULKAN_HPP_NAMESPACE
       fullScreenExclusiveSupported = fullScreenExclusiveSupported_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -63544,6 +64532,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SurfaceFullScreenExclusiveInfoEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -63556,6 +64545,7 @@ namespace VULKAN_HPP_NAMESPACE
       fullScreenExclusive = fullScreenExclusive_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -63630,6 +64620,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SurfaceFullScreenExclusiveWin32InfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -63641,6 +64632,7 @@ namespace VULKAN_HPP_NAMESPACE
       hmonitor = hmonitor_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -63711,6 +64703,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SurfaceProtectedCapabilitiesKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -63723,6 +64716,7 @@ namespace VULKAN_HPP_NAMESPACE
       supportsProtected = supportsProtected_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -63792,6 +64786,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SwapchainCounterCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -63804,6 +64799,7 @@ namespace VULKAN_HPP_NAMESPACE
       surfaceCounters = surfaceCounters_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -63942,6 +64938,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SwapchainCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -64016,7 +65013,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     SwapchainCreateInfoKHR & setQueueFamilyIndices(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -64024,7 +65021,7 @@ namespace VULKAN_HPP_NAMESPACE
       pQueueFamilyIndices   = queueFamilyIndices_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     SwapchainCreateInfoKHR &
       setPreTransform( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR preTransform_ ) VULKAN_HPP_NOEXCEPT
@@ -64057,6 +65054,7 @@ namespace VULKAN_HPP_NAMESPACE
       oldSwapchain = oldSwapchain_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -64151,6 +65149,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     SwapchainDisplayNativeHdrCreateInfoAMD & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -64163,6 +65162,7 @@ namespace VULKAN_HPP_NAMESPACE
       localDimmingEnable = localDimmingEnable_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -64320,6 +65320,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     TimelineSemaphoreSubmitInfo & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -64338,7 +65339,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     TimelineSemaphoreSubmitInfo & setWaitSemaphoreValues(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & waitSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -64346,7 +65347,7 @@ namespace VULKAN_HPP_NAMESPACE
       pWaitSemaphoreValues    = waitSemaphoreValues_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     TimelineSemaphoreSubmitInfo &
       setSignalSemaphoreValueCount( uint32_t signalSemaphoreValueCount_ ) VULKAN_HPP_NOEXCEPT
@@ -64362,7 +65363,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     TimelineSemaphoreSubmitInfo & setSignalSemaphoreValues(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & signalSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -64370,7 +65371,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSignalSemaphoreValues    = signalSemaphoreValues_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -64452,6 +65454,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     TraceRaysIndirectCommandKHR & setWidth( uint32_t width_ ) VULKAN_HPP_NOEXCEPT
     {
       width = width_;
@@ -64469,6 +65472,7 @@ namespace VULKAN_HPP_NAMESPACE
       depth = depth_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -64543,6 +65547,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ValidationCacheCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -64568,7 +65573,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     template <typename T>
     ValidationCacheCreateInfoEXT &
       setInitialData( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const T> const & initialData_ ) VULKAN_HPP_NOEXCEPT
@@ -64577,7 +65582,8 @@ namespace VULKAN_HPP_NAMESPACE
       pInitialData    = initialData_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -64668,6 +65674,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ValidationFeaturesEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -64688,7 +65695,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ValidationFeaturesEXT & setEnabledValidationFeatures(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT> const &
         enabledValidationFeatures_ ) VULKAN_HPP_NOEXCEPT
@@ -64697,7 +65704,7 @@ namespace VULKAN_HPP_NAMESPACE
       pEnabledValidationFeatures    = enabledValidationFeatures_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     ValidationFeaturesEXT &
       setDisabledValidationFeatureCount( uint32_t disabledValidationFeatureCount_ ) VULKAN_HPP_NOEXCEPT
@@ -64713,7 +65720,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ValidationFeaturesEXT & setDisabledValidationFeatures(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT> const &
         disabledValidationFeatures_ ) VULKAN_HPP_NOEXCEPT
@@ -64722,7 +65729,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDisabledValidationFeatures    = disabledValidationFeatures_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -64808,6 +65816,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ValidationFlagsEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -64827,7 +65836,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     ValidationFlagsEXT & setDisabledValidationChecks(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ValidationCheckEXT> const &
         disabledValidationChecks_ ) VULKAN_HPP_NOEXCEPT
@@ -64836,7 +65845,8 @@ namespace VULKAN_HPP_NAMESPACE
       pDisabledValidationChecks    = disabledValidationChecks_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -64916,6 +65926,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VertexInputAttributeDescription2EXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -64945,6 +65956,7 @@ namespace VULKAN_HPP_NAMESPACE
       offset = offset_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65025,6 +66037,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VertexInputBindingDescription2EXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65055,6 +66068,7 @@ namespace VULKAN_HPP_NAMESPACE
       divisor = divisor_;
       return *this;
     }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65129,6 +66143,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     ViSurfaceCreateInfoNN & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65146,6 +66161,7 @@ namespace VULKAN_HPP_NAMESPACE
       window = window_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65222,6 +66238,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoPictureResourceKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65252,6 +66269,7 @@ namespace VULKAN_HPP_NAMESPACE
       imageViewBinding = imageViewBinding_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoPictureResourceKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65328,6 +66346,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoReferenceSlotKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65346,6 +66365,7 @@ namespace VULKAN_HPP_NAMESPACE
       pPictureResource = pPictureResource_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoReferenceSlotKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65444,6 +66464,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoBeginCodingInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65489,7 +66510,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoBeginCodingInfoKHR & setReferenceSlots(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR> const &
         referenceSlots_ ) VULKAN_HPP_NOEXCEPT
@@ -65498,7 +66519,8 @@ namespace VULKAN_HPP_NAMESPACE
       pReferenceSlots    = referenceSlots_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65581,6 +66603,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoBindMemoryKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65610,6 +66633,7 @@ namespace VULKAN_HPP_NAMESPACE
       memorySize = memorySize_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoBindMemoryKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65778,6 +66802,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoCodingControlInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65789,6 +66814,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -65938,6 +66964,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH264DpbSlotInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -65950,6 +66977,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStdReferenceInfo = pStdReferenceInfo_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66019,6 +67047,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH264MvcEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66030,6 +67059,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStdMvc = pStdMvc_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH264MvcEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66113,6 +67143,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH264PictureInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66138,7 +67169,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeH264PictureInfoEXT & setSlicesDataOffsets(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & slicesDataOffsets_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -66146,7 +67177,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSlicesDataOffsets = slicesDataOffsets_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66223,6 +67255,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH264ProfileEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66241,6 +67274,7 @@ namespace VULKAN_HPP_NAMESPACE
       fieldLayout = fieldLayout_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66319,6 +67353,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH264SessionCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66338,6 +67373,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStdExtensionVersion = pStdExtensionVersion_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66432,6 +67468,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH264SessionParametersAddInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66451,7 +67488,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeH264SessionParametersAddInfoEXT &
       setSpsStd( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH264SequenceParameterSet> const & spsStd_ )
         VULKAN_HPP_NOEXCEPT
@@ -66460,7 +67497,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSpsStd     = spsStd_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoDecodeH264SessionParametersAddInfoEXT & setPpsStdCount( uint32_t ppsStdCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -66475,7 +67512,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeH264SessionParametersAddInfoEXT &
       setPpsStd( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH264PictureParameterSet> const & ppsStd_ )
         VULKAN_HPP_NOEXCEPT
@@ -66484,7 +67521,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPpsStd     = ppsStd_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66570,6 +67608,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH264SessionParametersCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66594,6 +67633,7 @@ namespace VULKAN_HPP_NAMESPACE
       pParametersAddInfo = pParametersAddInfo_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66742,6 +67782,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH265DpbSlotInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66754,6 +67795,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStdReferenceInfo = pStdReferenceInfo_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66838,6 +67880,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH265PictureInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66863,7 +67906,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeH265PictureInfoEXT & setSlicesDataOffsets(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & slicesDataOffsets_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -66871,7 +67914,8 @@ namespace VULKAN_HPP_NAMESPACE
       pSlicesDataOffsets = slicesDataOffsets_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -66945,6 +67989,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH265ProfileEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -66956,6 +68001,7 @@ namespace VULKAN_HPP_NAMESPACE
       stdProfileIdc = stdProfileIdc_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -67032,6 +68078,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH265SessionCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -67051,6 +68098,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStdExtensionVersion = pStdExtensionVersion_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -67145,6 +68193,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH265SessionParametersAddInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -67164,7 +68213,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeH265SessionParametersAddInfoEXT &
       setSpsStd( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265SequenceParameterSet> const & spsStd_ )
         VULKAN_HPP_NOEXCEPT
@@ -67173,7 +68222,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSpsStd     = spsStd_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoDecodeH265SessionParametersAddInfoEXT & setPpsStdCount( uint32_t ppsStdCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -67188,7 +68237,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeH265SessionParametersAddInfoEXT &
       setPpsStd( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265PictureParameterSet> const & ppsStd_ )
         VULKAN_HPP_NOEXCEPT
@@ -67197,7 +68246,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPpsStd     = ppsStd_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -67283,6 +68333,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeH265SessionParametersCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -67307,6 +68358,7 @@ namespace VULKAN_HPP_NAMESPACE
       pParametersAddInfo = pParametersAddInfo_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -67424,6 +68476,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoDecodeInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -67493,7 +68546,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeInfoKHR & setReferenceSlots(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR> const &
         referenceSlots_ ) VULKAN_HPP_NOEXCEPT
@@ -67502,7 +68555,8 @@ namespace VULKAN_HPP_NAMESPACE
       pReferenceSlots    = referenceSlots_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -67607,6 +68661,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264CapabilitiesEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -67685,6 +68740,7 @@ namespace VULKAN_HPP_NAMESPACE
       stdExtensionVersion = stdExtensionVersion_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -67774,6 +68830,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264DpbSlotInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -67792,6 +68849,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStdPictureInfo = pStdPictureInfo_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -67886,6 +68944,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264EmitPictureParametersEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -67917,7 +68976,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264EmitPictureParametersEXT & setPsIdEntries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint8_t> const & psIdEntries_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -67925,7 +68984,8 @@ namespace VULKAN_HPP_NAMESPACE
       ppsIdEntries    = psIdEntries_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -68042,6 +69102,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264NaluSliceEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -68074,7 +69135,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264NaluSliceEXT & setRefFinalList0Entries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT> const &
         refFinalList0Entries_ ) VULKAN_HPP_NOEXCEPT
@@ -68083,7 +69144,7 @@ namespace VULKAN_HPP_NAMESPACE
       pRefFinalList0Entries   = refFinalList0Entries_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoEncodeH264NaluSliceEXT & setRefFinalList1EntryCount( uint8_t refFinalList1EntryCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -68098,7 +69159,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264NaluSliceEXT & setRefFinalList1Entries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT> const &
         refFinalList1Entries_ ) VULKAN_HPP_NOEXCEPT
@@ -68107,7 +69168,7 @@ namespace VULKAN_HPP_NAMESPACE
       pRefFinalList1Entries   = refFinalList1Entries_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoEncodeH264NaluSliceEXT & setPrecedingNaluBytes( uint32_t precedingNaluBytes_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -68126,6 +69187,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxQp = maxQp_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -68209,6 +69271,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264ProfileEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -68220,6 +69283,7 @@ namespace VULKAN_HPP_NAMESPACE
       stdProfileIdc = stdProfileIdc_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -68298,6 +69362,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264SessionCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -68324,6 +69389,7 @@ namespace VULKAN_HPP_NAMESPACE
       pStdExtensionVersion = pStdExtensionVersion_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -68419,6 +69485,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264SessionParametersAddInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -68438,7 +69505,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264SessionParametersAddInfoEXT &
       setSpsStd( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH264SequenceParameterSet> const & spsStd_ )
         VULKAN_HPP_NOEXCEPT
@@ -68447,7 +69514,7 @@ namespace VULKAN_HPP_NAMESPACE
       pSpsStd     = spsStd_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoEncodeH264SessionParametersAddInfoEXT & setPpsStdCount( uint32_t ppsStdCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -68462,7 +69529,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264SessionParametersAddInfoEXT &
       setPpsStd( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH264PictureParameterSet> const & ppsStd_ )
         VULKAN_HPP_NOEXCEPT
@@ -68471,7 +69538,8 @@ namespace VULKAN_HPP_NAMESPACE
       pPpsStd     = ppsStd_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -68557,6 +69625,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264SessionParametersCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -68581,6 +69650,7 @@ namespace VULKAN_HPP_NAMESPACE
       pParametersAddInfo = pParametersAddInfo_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -68687,6 +69757,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeH264VclFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -68707,7 +69778,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264VclFrameInfoEXT & setRefDefaultFinalList0Entries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT> const &
         refDefaultFinalList0Entries_ ) VULKAN_HPP_NOEXCEPT
@@ -68716,7 +69787,7 @@ namespace VULKAN_HPP_NAMESPACE
       pRefDefaultFinalList0Entries   = refDefaultFinalList0Entries_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoEncodeH264VclFrameInfoEXT &
       setRefDefaultFinalList1EntryCount( uint8_t refDefaultFinalList1EntryCount_ ) VULKAN_HPP_NOEXCEPT
@@ -68732,7 +69803,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264VclFrameInfoEXT & setRefDefaultFinalList1Entries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT> const &
         refDefaultFinalList1Entries_ ) VULKAN_HPP_NOEXCEPT
@@ -68741,7 +69812,7 @@ namespace VULKAN_HPP_NAMESPACE
       pRefDefaultFinalList1Entries   = refDefaultFinalList1Entries_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoEncodeH264VclFrameInfoEXT & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -68756,7 +69827,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeH264VclFrameInfoEXT & setNaluSliceEntries(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT> const &
         naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT
@@ -68765,7 +69836,7 @@ namespace VULKAN_HPP_NAMESPACE
       pNaluSliceEntries   = naluSliceEntries_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VideoEncodeH264VclFrameInfoEXT & setPCurrentPictureInfo(
       const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pCurrentPictureInfo_ ) VULKAN_HPP_NOEXCEPT
@@ -68773,6 +69844,7 @@ namespace VULKAN_HPP_NAMESPACE
       pCurrentPictureInfo = pCurrentPictureInfo_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -68898,6 +69970,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -68969,7 +70042,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeInfoKHR & setReferenceSlots(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR> const &
         referenceSlots_ ) VULKAN_HPP_NOEXCEPT
@@ -68978,7 +70051,8 @@ namespace VULKAN_HPP_NAMESPACE
       pReferenceSlots    = referenceSlots_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69077,6 +70151,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEncodeRateControlInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69127,6 +70202,7 @@ namespace VULKAN_HPP_NAMESPACE
       virtualBufferSizeInMs = virtualBufferSizeInMs_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69208,6 +70284,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoEndCodingInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69219,6 +70296,7 @@ namespace VULKAN_HPP_NAMESPACE
       flags = flags_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69359,6 +70437,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoGetMemoryPropertiesKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69377,6 +70456,7 @@ namespace VULKAN_HPP_NAMESPACE
       pMemoryRequirements = pMemoryRequirements_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoGetMemoryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69450,6 +70530,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoQueueFamilyProperties2KHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69462,6 +70543,7 @@ namespace VULKAN_HPP_NAMESPACE
       videoCodecOperations = videoCodecOperations_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoQueueFamilyProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69547,6 +70629,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoSessionCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69605,6 +70688,7 @@ namespace VULKAN_HPP_NAMESPACE
       maxReferencePicturesActiveCount = maxReferencePicturesActiveCount_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69692,6 +70776,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoSessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69711,6 +70796,7 @@ namespace VULKAN_HPP_NAMESPACE
       videoSession = videoSession_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69786,6 +70872,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     VideoSessionParametersUpdateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69797,6 +70884,7 @@ namespace VULKAN_HPP_NAMESPACE
       updateSequenceCount = updateSequenceCount_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -69871,6 +70959,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     WaylandSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -69895,6 +70984,7 @@ namespace VULKAN_HPP_NAMESPACE
       surface = surface_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -70037,6 +71127,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Win32KeyedMutexAcquireReleaseInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -70056,7 +71147,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireSyncs(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DeviceMemory> const & acquireSyncs_ )
       VULKAN_HPP_NOEXCEPT
@@ -70065,7 +71156,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAcquireSyncs = acquireSyncs_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireKeys( const uint64_t * pAcquireKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70073,7 +71164,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireKeys(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & acquireKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70081,7 +71172,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAcquireKeys = acquireKeys_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireTimeouts( const uint32_t * pAcquireTimeouts_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70089,7 +71180,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireTimeouts(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & acquireTimeouts_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70097,7 +71188,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAcquireTimeouts = acquireTimeouts_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseCount( uint32_t releaseCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70112,7 +71203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseSyncs(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DeviceMemory> const & releaseSyncs_ )
       VULKAN_HPP_NOEXCEPT
@@ -70121,7 +71212,7 @@ namespace VULKAN_HPP_NAMESPACE
       pReleaseSyncs = releaseSyncs_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseKeys( const uint64_t * pReleaseKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70129,7 +71220,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseKeys(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & releaseKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70137,7 +71228,8 @@ namespace VULKAN_HPP_NAMESPACE
       pReleaseKeys = releaseKeys_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -70286,6 +71378,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Win32KeyedMutexAcquireReleaseInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -70305,7 +71398,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoNV & setAcquireSyncs(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DeviceMemory> const & acquireSyncs_ )
       VULKAN_HPP_NOEXCEPT
@@ -70314,7 +71407,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAcquireSyncs = acquireSyncs_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireKeys( const uint64_t * pAcquireKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70322,7 +71415,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoNV & setAcquireKeys(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & acquireKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70330,7 +71423,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAcquireKeys = acquireKeys_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoNV &
       setPAcquireTimeoutMilliseconds( const uint32_t * pAcquireTimeoutMilliseconds_ ) VULKAN_HPP_NOEXCEPT
@@ -70339,7 +71432,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoNV & setAcquireTimeoutMilliseconds(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & acquireTimeoutMilliseconds_ )
       VULKAN_HPP_NOEXCEPT
@@ -70348,7 +71441,7 @@ namespace VULKAN_HPP_NAMESPACE
       pAcquireTimeoutMilliseconds = acquireTimeoutMilliseconds_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoNV & setReleaseCount( uint32_t releaseCount_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70363,7 +71456,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoNV & setReleaseSyncs(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DeviceMemory> const & releaseSyncs_ )
       VULKAN_HPP_NOEXCEPT
@@ -70372,7 +71465,7 @@ namespace VULKAN_HPP_NAMESPACE
       pReleaseSyncs = releaseSyncs_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseKeys( const uint64_t * pReleaseKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70380,7 +71473,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     Win32KeyedMutexAcquireReleaseInfoNV & setReleaseKeys(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint64_t> const & releaseKeys_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -70388,7 +71481,8 @@ namespace VULKAN_HPP_NAMESPACE
       pReleaseKeys = releaseKeys_.data();
       return *this;
     }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -70473,6 +71567,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     Win32SurfaceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -70496,6 +71591,7 @@ namespace VULKAN_HPP_NAMESPACE
       hwnd = hwnd_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -70617,6 +71713,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     WriteDescriptorSet & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -70660,7 +71757,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     WriteDescriptorSet & setImageInfo(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorImageInfo> const &
         imageInfo_ ) VULKAN_HPP_NOEXCEPT
@@ -70669,7 +71766,7 @@ namespace VULKAN_HPP_NAMESPACE
       pImageInfo      = imageInfo_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     WriteDescriptorSet &
       setPBufferInfo( const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo * pBufferInfo_ ) VULKAN_HPP_NOEXCEPT
@@ -70678,7 +71775,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     WriteDescriptorSet & setBufferInfo(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo> const &
         bufferInfo_ ) VULKAN_HPP_NOEXCEPT
@@ -70687,7 +71784,7 @@ namespace VULKAN_HPP_NAMESPACE
       pBufferInfo     = bufferInfo_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     WriteDescriptorSet &
       setPTexelBufferView( const VULKAN_HPP_NAMESPACE::BufferView * pTexelBufferView_ ) VULKAN_HPP_NOEXCEPT
@@ -70696,7 +71793,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     WriteDescriptorSet & setTexelBufferView(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::BufferView> const & texelBufferView_ )
       VULKAN_HPP_NOEXCEPT
@@ -70705,7 +71802,8 @@ namespace VULKAN_HPP_NAMESPACE
       pTexelBufferView = texelBufferView_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -70800,6 +71898,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     WriteDescriptorSetAccelerationStructureKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -70820,7 +71919,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     WriteDescriptorSetAccelerationStructureKHR & setAccelerationStructures(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const &
         accelerationStructures_ ) VULKAN_HPP_NOEXCEPT
@@ -70829,7 +71928,8 @@ namespace VULKAN_HPP_NAMESPACE
       pAccelerationStructures    = accelerationStructures_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -70918,6 +72018,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     WriteDescriptorSetAccelerationStructureNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -70938,7 +72039,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     WriteDescriptorSetAccelerationStructureNV & setAccelerationStructures(
       VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const &
         accelerationStructures_ ) VULKAN_HPP_NOEXCEPT
@@ -70947,7 +72048,8 @@ namespace VULKAN_HPP_NAMESPACE
       pAccelerationStructures    = accelerationStructures_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -71032,6 +72134,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     WriteDescriptorSetInlineUniformBlockEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -71050,7 +72153,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     template <typename T>
     WriteDescriptorSetInlineUniformBlockEXT &
       setData( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const T> const & data_ ) VULKAN_HPP_NOEXCEPT
@@ -71059,7 +72162,8 @@ namespace VULKAN_HPP_NAMESPACE
       pData    = data_.data();
       return *this;
     }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkWriteDescriptorSetInlineUniformBlockEXT const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -71134,6 +72238,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     XcbSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -71157,6 +72262,7 @@ namespace VULKAN_HPP_NAMESPACE
       window = window_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
@@ -71232,6 +72338,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
     XlibSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -71255,6 +72362,7 @@ namespace VULKAN_HPP_NAMESPACE
       window = window_;
       return *this;
     }
+#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
     operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {