diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 14e2fb4..2f70bdd 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -41,28 +41,27 @@ std::vector<std::string> extractHandleCommands( std::vector<std::string> const &
                                                 std::set<std::string> const &    handleCommands,
                                                 std::set<std::string> &          listedCommands );
 std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" );
-std::string generateEnumValueName( std::string const & name,
-                                   std::string const & prefix,
-                                   std::string const & postfix,
-                                   bool                bitmask,
-                                   std::string const & tag );
+std::string generateEnumValueName( std::string const &           enumName,
+                                   std::string const &           valueName,
+                                   bool                          bitmask,
+                                   std::set<std::string> const & tags );
 std::string generateStandardArray( std::string const & type, std::vector<std::string> const & sizes );
 std::map<std::string, std::string> getAttributes( tinyxml2::XMLElement const * element );
 template <typename ElementContainer>
 std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer const * element );
-std::string getEnumPostfix( std::string const & name, std::set<std::string> const & tags, std::string & prefix );
-std::string namespacedType( std::string const & type );
-std::string readTypePostfix( tinyxml2::XMLNode const * node );
-std::string readTypePrefix( tinyxml2::XMLNode const * node );
-void        replaceAll( std::string & str, std::string const & from, std::string const & to );
-std::string replaceWithMap( std::string const & input, std::map<std::string, std::string> replacements );
-std::string startLowerCase( std::string const & input );
-std::string startUpperCase( std::string const & input );
-std::string stripPostfix( std::string const & value, std::string const & postfix );
-std::string stripPluralS( std::string const & name );
-std::string stripPrefix( std::string const & value, std::string const & prefix );
-std::string toCamelCase( std::string const & value );
-std::string toUpperCase( std::string const & name );
+std::pair<std::string, std::string>
+                         getEnumSuffixes( std::string const & name, bool bitmask, std::set<std::string> const & tags );
+std::string              readTypePostfix( tinyxml2::XMLNode const * node );
+std::string              readTypePrefix( tinyxml2::XMLNode const * node );
+void                     replaceAll( std::string & str, std::string const & from, std::string const & to );
+std::string              replaceWithMap( std::string const & input, std::map<std::string, std::string> replacements );
+std::string              startLowerCase( std::string const & input );
+std::string              startUpperCase( std::string const & input );
+std::string              stripPostfix( std::string const & value, std::string const & postfix );
+std::string              stripPluralS( std::string const & name );
+std::string              stripPrefix( std::string const & value, std::string const & prefix );
+std::string              toCamelCase( std::string const & value );
+std::string              toUpperCase( std::string const & name );
 std::vector<std::string> tokenize( std::string const & tokenString, std::string const & separator );
 std::string              trim( std::string const & input );
 std::string              trimEnd( std::string const & input );
@@ -330,13 +329,20 @@ std::string findTag( std::set<std::string> const & tags, std::string const & nam
   return ( tagIt != tags.end() ) ? *tagIt : "";
 }
 
-std::string generateEnumValueName( std::string const & name,
-                                   std::string const & prefix,
-                                   std::string const & postfix,
-                                   bool                bitmask,
-                                   std::string const & tag )
+std::string generateEnumValueName( std::string const &           enumName,
+                                   std::string const &           valueName,
+                                   bool                          bitmask,
+                                   std::set<std::string> const & tags )
 {
-  std::string result = "e" + toCamelCase( stripPostfix( stripPrefix( name, prefix ), postfix ) );
+  std::string prefix, postfix;
+  std::tie( prefix, postfix ) = getEnumSuffixes( enumName, bitmask, tags );
+  std::string tag             = findTag( tags, valueName, "" );
+  if ( postfix == "_" + tag )
+  {
+    tag = findTag( tags, valueName, postfix );
+  }
+
+  std::string result = "e" + toCamelCase( stripPostfix( stripPrefix( valueName, prefix ), postfix ) );
   if ( bitmask )
   {
     size_t pos = result.find( "Bit" );
@@ -385,11 +391,33 @@ std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer con
   return childElements;
 }
 
-std::string getEnumPostfix( std::string const & name, std::set<std::string> const & tags, std::string & prefix )
+std::pair<std::string, std::string>
+  getEnumSuffixes( std::string const & name, bool bitmask, std::set<std::string> const & tags )
 {
-  std::string postfix;
-  if ( name != "VkResult" )
+  std::string prefix, postfix;
+  if ( name == "VkResult" )
   {
+    prefix = "VK_";
+  }
+  else
+  {
+    if ( bitmask )
+    {
+      // for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case
+      // end that with "Bit"
+      size_t pos = name.find( "FlagBits" );
+      assert( pos != std::string::npos );
+      std::string shortenedName = name;
+      shortenedName.erase( pos, strlen( "FlagBits" ) );
+      std::string tag = findTag( tags, shortenedName );
+      prefix          = toUpperCase( stripPostfix( shortenedName, tag ) ) + "_";
+    }
+    else
+    {
+      // for a non-bitmask enum, convert the name to upper case
+      prefix = toUpperCase( name ) + "_";
+    }
+
     // if the enum name contains a tag move it from the prefix to the postfix to generate correct enum value names.
     for ( auto const & tag : tags )
     {
@@ -406,7 +434,8 @@ std::string getEnumPostfix( std::string const & name, std::set<std::string> cons
       }
     }
   }
-  return postfix;
+
+  return std::make_pair( prefix, postfix );
 }
 
 std::pair<std::vector<std::string>, std::string> readModifiers( tinyxml2::XMLNode const * node )
@@ -1004,9 +1033,9 @@ void VulkanHppGenerator::appendBitmask( std::string &                      str,
     {
       std::string enter, leave;
       std::tie( enter, leave ) = generateProtection( value.extension );
+      std::string valueName    = generateEnumValueName( "Vk" + name, value.name, true, m_tags );
       allFlags += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + "        " +
-                  ( encounteredFlag ? "| " : "  " ) + bitmaskType + "( " + enumName + "::" + value.translatedName +
-                  " )";
+                  ( encounteredFlag ? "| " : "  " ) + bitmaskType + "( " + enumName + "::" + valueName + " )";
       encounteredFlag = true;
       previousEnter   = enter;
       previousLeave   = leave;
@@ -1092,8 +1121,9 @@ void VulkanHppGenerator::appendBitmaskToStringFunction( std::string &
       {
         std::string enter, leave;
         std::tie( enter, leave ) = generateProtection( evd.extension );
-        str += enter + "    if ( value & " + enumName + "::" + evd.translatedName + " ) result += \"" +
-               evd.translatedName.substr( 1 ) + " | \";\n" + leave;
+        std::string valueName    = generateEnumValueName( "Vk" + enumName, evd.name, true, m_tags );
+        str += enter + "    if ( value & " + enumName + "::" + valueName + " ) result += \"" + valueName.substr( 1 ) +
+               " | \";\n" + leave;
       }
     }
     str += "    return \"{ \" + result.substr(0, result.size() - 3) + \" }\";\n";
@@ -2645,7 +2675,8 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
     str += " : " + bitmaskIt->first;
   }
 
-  std::string enumList, previousEnter, previousLeave;
+  std::string           enumList, previousEnter, previousLeave;
+  std::set<std::string> valueNames;
   for ( auto const & value : enumData.second.values )
   {
     std::string enter, leave;
@@ -2654,7 +2685,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
     {
       enumList += previousLeave + enter;
     }
-    enumList += "    " + value.translatedName + " = " + value.name + ",\n";
+    std::string valueName = generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask, m_tags );
+    enumList += "    " + valueName + " = " + value.name + ",\n";
+    assert( valueNames.find( valueName ) == valueNames.end() );
+    valueNames.insert( valueName );
 
     previousEnter = enter;
     previousLeave = leave;
@@ -2663,11 +2697,16 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
 
   for ( auto const & alias : enumData.second.aliases )
   {
+    std::string aliasName =
+      generateEnumValueName( enumData.second.alias.empty() ? enumData.first : enumData.second.alias,
+                             alias.first,
+                             enumData.second.isBitmask,
+                             m_tags );
     // make sure to only list alias values that differ from all non-alias values
-    if ( std::find_if( enumData.second.values.begin(),
-                       enumData.second.values.end(),
-                       [&alias]( EnumValueData const & evd )
-                       { return alias.second.translatedName == evd.translatedName; } ) == enumData.second.values.end() )
+    if ( std::find_if( valueNames.begin(),
+                       valueNames.end(),
+                       [&aliasName]( std::string const & valueName )
+                       { return aliasName == valueName; } ) == valueNames.end() )
     {
 #if !defined( NDEBUG )
       auto enumIt = std::find_if( enumData.second.values.begin(),
@@ -2684,7 +2723,7 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
       assert( enumIt != enumData.second.values.end() );
       assert( enumIt->extension.empty() || generateProtection( enumIt->extension ).first.empty() );
 #endif
-      enumList += "    " + alias.second.translatedName + " = " + alias.first + ",\n";
+      enumList += "    " + aliasName + " = " + alias.first + ",\n";
     }
   }
   if ( enumList.empty() )
@@ -2780,11 +2819,13 @@ void VulkanHppGenerator::appendEnums( std::string & str ) const
 void VulkanHppGenerator::appendEnumInitializer( std::string &                      str,
                                                 TypeInfo const &                   type,
                                                 std::vector<std::string> const &   arraySizes,
-                                                std::vector<EnumValueData> const & values ) const
+                                                std::vector<EnumValueData> const & values,
+                                                bool                               bitmask ) const
 {
   // enum arguments might need special initialization
   assert( type.prefix.empty() && !values.empty() );
-  std::string value = "VULKAN_HPP_NAMESPACE::" + stripPrefix( type.type, "Vk" ) + "::" + values.front().translatedName;
+  std::string valueName = generateEnumValueName( type.type, values.front().name, bitmask, m_tags );
+  std::string value     = "VULKAN_HPP_NAMESPACE::" + stripPrefix( type.type, "Vk" ) + "::" + valueName;
   if ( arraySizes.empty() )
   {
     str += value;
@@ -2837,8 +2878,8 @@ void VulkanHppGenerator::appendEnumToString( std::string &
       {
         str += previousLeave + enter;
       }
-      str += "      case " + enumName + "::" + value.translatedName + " : return \"" +
-             value.translatedName.substr( 1 ) + "\";\n";
+      std::string valueName = generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask, m_tags );
+      str += "      case " + enumName + "::" + valueName + " : return \"" + valueName.substr( 1 ) + "\";\n";
       previousEnter = enter;
       previousLeave = leave;
     }
@@ -3317,13 +3358,14 @@ ${CppTypeFromDebugReportObjectTypeEXT}
 ${usingAlias}${leave})";
 
     std::string className = stripPrefix( handleData.first, "Vk" );
+    std::string valueName = handleData.second.objTypeEnum;
+    valueName             = valueName.replace( 3, 0, "DEBUG_REPORT_" ) + "_EXT";
 
     auto enumIt = m_enums.find( "VkDebugReportObjectTypeEXT" );
     assert( enumIt != m_enums.end() );
-    auto valueIt =
-      std::find_if( enumIt->second.values.begin(),
-                    enumIt->second.values.end(),
-                    [&className]( EnumValueData const & evd ) { return evd.translatedName == "e" + className; } );
+    auto                     valueIt                                     = std::find_if( enumIt->second.values.begin(),
+                                 enumIt->second.values.end(),
+                                 [&valueName]( EnumValueData const & evd ) { return valueName == evd.name; } );
     static const std::string cppTypeFromDebugReportObjectTypeEXTTemplate = R"(
   template <>
   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::e${className}>
@@ -3335,8 +3377,9 @@ ${usingAlias}${leave})";
       ( valueIt != enumIt->second.values.end() )
                      ? replaceWithMap( cppTypeFromDebugReportObjectTypeEXTTemplate, { { "className", className } } )
                      : "";
-    std::string debugReportObjectType =
-      ( valueIt != enumIt->second.values.end() ) ? valueIt->translatedName : "eUnknown";
+    std::string debugReportObjectType = ( valueIt != enumIt->second.values.end() )
+                                          ? generateEnumValueName( enumIt->first, valueIt->name, false, m_tags )
+                                          : "eUnknown";
 
     std::string enter, leave;
     std::tie( enter, leave ) = generateProtection( handleData.first, !handleData.second.alias.empty() );
@@ -3364,7 +3407,7 @@ ${usingAlias}${leave})";
                              { "enter", enter },
                              { "leave", leave },
                              { "memberName", startLowerCase( stripPrefix( handleData.first, "Vk" ) ) },
-                             { "objTypeEnum", valueIt->translatedName },
+                             { "objTypeEnum", generateEnumValueName( enumIt->first, valueIt->name, false, m_tags ) },
                              { "usingAlias", usingAlias } } );
   }
 
@@ -3649,18 +3692,19 @@ ${enter}  class ${className} : public SystemError
   };
 ${leave})";
 
-  auto enumData = m_enums.find( "VkResult" );
-  for ( auto const & value : enumData->second.values )
+  auto enumIt = m_enums.find( "VkResult" );
+  for ( auto const & value : enumIt->second.values )
   {
-    if ( beginsWith( value.translatedName, "eError" ) )
+    if ( beginsWith( value.name, "VK_ERROR" ) )
     {
       std::string enter, leave;
       std::tie( enter, leave ) = generateProtection( value.extension );
+      std::string valueName    = generateEnumValueName( enumIt->first, value.name, false, m_tags );
       str += replaceWithMap( templateString,
-                             { { "className", stripPrefix( value.translatedName, "eError" ) + "Error" },
+                             { { "className", stripPrefix( valueName, "eError" ) + "Error" },
                                { "enter", enter },
-                               { "enumName", stripPrefix( enumData->first, "Vk" ) },
-                               { "enumMemberName", value.translatedName },
+                               { "enumName", stripPrefix( enumIt->first, "Vk" ) },
+                               { "enumMemberName", valueName },
                                { "leave", leave } } );
     }
   }
@@ -3703,16 +3747,18 @@ void VulkanHppGenerator::appendRAIIHandle( std::string &
                     enumIt->second.values.end(),
                     [&handle]( EnumValueData const & evd ) { return evd.name == handle.second.objTypeEnum; } );
     assert( valueIt != enumIt->second.values.end() );
-    std::string objTypeEnum = valueIt->translatedName;
+    std::string objTypeEnum = generateEnumValueName( enumIt->first, valueIt->name, false, m_tags );
 
     enumIt = m_enums.find( "VkDebugReportObjectTypeEXT" );
     assert( enumIt != m_enums.end() );
-    valueIt =
-      std::find_if( enumIt->second.values.begin(),
-                    enumIt->second.values.end(),
-                    [&handleType]( EnumValueData const & evd ) { return evd.translatedName == "e" + handleType; } );
-    std::string debugReportObjectType =
-      ( valueIt != enumIt->second.values.end() ) ? valueIt->translatedName : "eUnknown";
+    std::string valueName             = handle.second.objTypeEnum;
+    valueName                         = valueName.replace( 3, 0, "DEBUG_REPORT_" ) + "_EXT";
+    valueIt                           = std::find_if( enumIt->second.values.begin(),
+                            enumIt->second.values.end(),
+                            [&valueName]( EnumValueData const & evd ) { return valueName == evd.name; } );
+    std::string debugReportObjectType = ( valueIt != enumIt->second.values.end() )
+                                          ? generateEnumValueName( enumIt->first, valueIt->name, false, m_tags )
+                                          : "eUnknown";
 
     std::string dispatcherType =
       ( ( handle.first == "VkDevice" ) ||
@@ -10457,7 +10503,8 @@ bool VulkanHppGenerator::appendStructConstructorArgument( std::string &      str
       auto enumIt = m_enums.find( memberData.type.type );
       if ( enumIt != m_enums.end() && memberData.type.postfix.empty() )
       {
-        appendEnumInitializer( str, memberData.type, memberData.arraySizes, enumIt->second.values );
+        appendEnumInitializer(
+          str, memberData.type, memberData.arraySizes, enumIt->second.values, enumIt->second.isBitmask );
       }
       else
       {
@@ -10502,14 +10549,15 @@ std::string VulkanHppGenerator::appendStructMembers( std::string &
       assert( enumIt != m_enums.end() );
       {
         std::string enumValue = member.values.front();
-        auto        nameIt    = std::find_if( enumIt->second.values.begin(),
-                                    enumIt->second.values.end(),
-                                    [&enumValue]( EnumValueData const & evd ) { return enumValue == evd.name; } );
-        assert( nameIt != enumIt->second.values.end() );
-        str += " = " + stripPrefix( member.type.type, "Vk" ) + "::" + nameIt->translatedName;
+        auto        valueIt   = std::find_if( enumIt->second.values.begin(),
+                                     enumIt->second.values.end(),
+                                     [&enumValue]( EnumValueData const & evd ) { return enumValue == evd.name; } );
+        assert( valueIt != enumIt->second.values.end() );
+        std::string valueName = generateEnumValueName( enumIt->first, valueIt->name, enumIt->second.isBitmask, m_tags );
+        str += " = " + stripPrefix( member.type.type, "Vk" ) + "::" + valueName;
         if ( member.name == "sType" )
         {
-          sTypeValue = nameIt->translatedName;
+          sTypeValue = valueName;
         }
       }
     }
@@ -10528,7 +10576,7 @@ std::string VulkanHppGenerator::appendStructMembers( std::string &
         auto enumIt = m_enums.find( member.type.type );
         if ( member.arraySizes.empty() && ( enumIt != m_enums.end() ) && member.type.postfix.empty() )
         {
-          appendEnumInitializer( str, member.type, member.arraySizes, enumIt->second.values );
+          appendEnumInitializer( str, member.type, member.arraySizes, enumIt->second.values, enumIt->second.isBitmask );
         }
         else
         {
@@ -10866,7 +10914,7 @@ void VulkanHppGenerator::appendStructureChainValidation( std::string & str )
 
 void VulkanHppGenerator::appendThrowExceptions( std::string & str ) const
 {
-  auto enumData = m_enums.find( "VkResult" );
+  auto enumIt = m_enums.find( "VkResult" );
 
   str +=
     "\n"
@@ -10874,14 +10922,15 @@ void VulkanHppGenerator::appendThrowExceptions( std::string & str ) const
     "  {\n"
     "    switch ( result )\n"
     "    {\n";
-  for ( auto const & value : enumData->second.values )
+  for ( auto const & value : enumIt->second.values )
   {
-    if ( beginsWith( value.translatedName, "eError" ) )
+    if ( beginsWith( value.name, "VK_ERROR" ) )
     {
       std::string enter, leave;
       std::tie( enter, leave ) = generateProtection( value.extension );
-      str += enter + "      case Result::" + value.translatedName + ": throw " +
-             stripPrefix( value.translatedName, "eError" ) + "Error( message );\n" + leave;
+      std::string valueName    = generateEnumValueName( enumIt->first, value.name, false, m_tags );
+      str += enter + "      case Result::" + valueName + ": throw " + stripPrefix( valueName, "eError" ) +
+             "Error( message );\n" + leave;
     }
   }
   str +=
@@ -11101,49 +11150,25 @@ void VulkanHppGenerator::appendUniqueTypes( std::string &                 str,
   str += "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/\n";
 }
 
-void VulkanHppGenerator::EnumData::addEnumAlias( int                 line,
-                                                 std::string const & name,
-                                                 std::string const & aliasName,
-                                                 std::string const & vkName )
+void VulkanHppGenerator::EnumData::addEnumAlias( int line, std::string const & name, std::string const & aliasName )
 {
   auto aliasIt = aliases.find( name );
   check( ( aliasIt == aliases.end() ) || ( aliasIt->second.name == aliasName ),
          line,
          "enum alias <" + name + "> already listed for a different enum value" );
-
-  // only list aliases that map to different vkNames
-  aliasIt = std::find_if( aliases.begin(),
-                          aliases.end(),
-                          [&vkName]( std::pair<std::string, EnumAliasData> const & aliasEntry )
-                          { return vkName == aliasEntry.second.translatedName; } );
-  if ( aliasIt == aliases.end() )
-  {
-    aliases.insert( std::make_pair( name, EnumAliasData( aliasName, vkName, line ) ) );
-  }
+  aliases.insert( std::make_pair( name, EnumAliasData( aliasName, line ) ) );
 }
 
 void VulkanHppGenerator::EnumData::addEnumValue( int                 line,
                                                  std::string const & valueName,
-                                                 bool                bitmask,
                                                  bool                bitpos,
-                                                 std::string const & prefix,
-                                                 std::string const & postfix,
-                                                 std::string const & extension,
-                                                 std::string const & tag )
+                                                 std::string const & extension )
 {
-  std::string translatedName = generateEnumValueName( valueName, prefix, postfix, bitmask, tag );
-
-  auto it =
-    std::find_if( values.begin(),
-                  values.end(),
-                  [&translatedName]( EnumValueData const & evd ) { return evd.translatedName == translatedName; } );
-  if ( it == values.end() )
+  auto valueIt = std::find_if(
+    values.begin(), values.end(), [&valueName]( EnumValueData const & evd ) { return evd.name == valueName; } );
+  if ( valueIt == values.end() )
   {
-    values.emplace_back( line, valueName, extension, bitpos, translatedName );
-  }
-  else
-  {
-    check( it->name == valueName, line, "enum value <" + valueName + "> maps to same C++-name as <" + it->name + ">" );
+    values.emplace_back( line, valueName, extension, bitpos );
   }
 }
 
@@ -11304,7 +11329,7 @@ void VulkanHppGenerator::checkCorrectness()
   }
   for ( auto const & objectTypeValue : objectTypeIt->second.values )
   {
-    if ( objectTypeValue.translatedName != "eUnknown" )
+    if ( objectTypeValue.name != "VK_OBJECT_TYPE_UNKNOWN" )
     {
       check( std::find_if( m_handles.begin(),
                            m_handles.end(),
@@ -11793,26 +11818,27 @@ void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
   std::set<std::string> seenCppTypes;
   for ( auto const & value : indexType->second.values )
   {
+    std::string valueName = generateEnumValueName( indexType->first, value.name, false, m_tags );
     std::string cppType;
-    if ( beginsWith( value.translatedName, "eUint8" ) )
+    if ( beginsWith( valueName, "eUint8" ) )
     {
       cppType = "uint8_t";
     }
-    else if ( beginsWith( value.translatedName, "eUint16" ) )
+    else if ( beginsWith( valueName, "eUint16" ) )
     {
       cppType = "uint16_t";
     }
-    else if ( beginsWith( value.translatedName, "eUint32" ) )
+    else if ( beginsWith( valueName, "eUint32" ) )
     {
       cppType = "uint32_t";
     }
-    else if ( beginsWith( value.translatedName, "eUint64" ) )
+    else if ( beginsWith( valueName, "eUint64" ) )
     {
       cppType = "uint64_t";  // No extension for this currently
     }
     else
     {
-      assert( beginsWith( value.translatedName, "eNone" ) );
+      assert( beginsWith( valueName, "eNone" ) );
     }
 
     if ( !cppType.empty() )
@@ -11830,7 +11856,7 @@ void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
           ">\n"
           "  {\n"
           "    static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::" +
-          value.translatedName +
+          valueName +
           ";\n"
           "  };\n";
       }
@@ -11839,7 +11865,7 @@ void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
         "\n"
         "  template <>\n"
         "  struct CppType<IndexType, IndexType::" +
-        value.translatedName +
+        valueName +
         ">\n"
         "  {\n"
         "    using Type = " +
@@ -12083,32 +12109,6 @@ std::string
   return sizeCheck;
 }
 
-std::string VulkanHppGenerator::getEnumPrefix( int line, std::string const & name, bool bitmask ) const
-{
-  std::string prefix;
-  if ( name == "VkResult" )
-  {
-    prefix = "VK_";
-  }
-  else if ( bitmask )
-  {
-    // for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case
-    // end that with "Bit"
-    size_t pos = name.find( "FlagBits" );
-    check( pos != std::string::npos, line, "bitmask <" + name + "> does not contain <FlagBits>" );
-    std::string shortenedName = name;
-    shortenedName.erase( pos, strlen( "FlagBits" ) );
-    std::string tag = findTag( m_tags, shortenedName );
-    prefix          = toUpperCase( stripPostfix( shortenedName, tag ) ) + "_";
-  }
-  else
-  {
-    // for a non-bitmask enum, convert the name to upper case
-    prefix = toUpperCase( name ) + "_";
-  }
-  return prefix;
-}
-
 std::string VulkanHppGenerator::getPlatform( std::string const & extension ) const
 {
   auto extensionIt = m_extensions.find( extension );
@@ -12713,30 +12713,24 @@ void VulkanHppGenerator::readDefine( tinyxml2::XMLElement const *
   check( m_defines.insert( name ).second, line, "define <" + name + "> has already been specified" );
 }
 
-void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const * element,
-                                   EnumData &                   enumData,
-                                   bool                         bitmask,
-                                   std::string const &          prefix,
-                                   std::string const &          postfix )
+void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const *              element,
+                                   std::map<std::string, EnumData>::iterator enumIt )
 {
   std::map<std::string, std::string> attributes = getAttributes( element );
   auto                               aliasIt    = attributes.find( "alias" );
   if ( aliasIt != attributes.end() )
   {
-    readEnumAlias( element, attributes, enumData, bitmask, prefix, postfix );
+    readEnumAlias( element, attributes, enumIt->second );
   }
   else
   {
-    readEnum( element, attributes, enumData, bitmask, prefix, postfix );
+    readEnum( element, attributes, enumIt );
   }
 }
 
 void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const *               element,
                                    std::map<std::string, std::string> const & attributes,
-                                   EnumData &                                 enumData,
-                                   bool                                       bitmask,
-                                   std::string const &                        prefix,
-                                   std::string const &                        postfix )
+                                   std::map<std::string, EnumData>::iterator  enumIt )
 {
   int line = element->GetLineNum();
   checkAttributes( line, attributes, { { "name", {} } }, { { "bitpos", {} }, { "comment", {} }, { "value", {} } } );
@@ -12758,22 +12752,19 @@ void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const *               el
       value = attribute.second;
     }
   }
+
+  std::string prefix = getEnumSuffixes( enumIt->first, enumIt->second.isBitmask, m_tags ).first;
   warn( beginsWith( name, prefix ),
         line,
         "encountered enum value <" + name + "> that does not begin with expected prefix <" + prefix + ">" );
 
-  std::string tag = findTag( m_tags, name, postfix );
-
   check( bitpos.empty() ^ value.empty(), line, "invalid set of attributes for enum <" + name + ">" );
-  enumData.addEnumValue( line, name, bitmask, !bitpos.empty(), prefix, postfix, "", tag );
+  enumIt->second.addEnumValue( line, name, !bitpos.empty(), "" );
 }
 
 void VulkanHppGenerator::readEnumAlias( tinyxml2::XMLElement const *               element,
                                         std::map<std::string, std::string> const & attributes,
-                                        EnumData &                                 enumData,
-                                        bool                                       bitmask,
-                                        std::string const &                        prefix,
-                                        std::string const &                        postfix )
+                                        EnumData &                                 enumData )
 {
   int line = element->GetLineNum();
   checkAttributes( line, attributes, { { "alias", {} }, { "name", {} } }, { { "comment", {} } } );
@@ -12795,8 +12786,7 @@ void VulkanHppGenerator::readEnumAlias( tinyxml2::XMLElement const *
   }
   assert( !name.empty() );
 
-  std::string tag = findTag( m_tags, name, postfix );
-  enumData.addEnumAlias( line, name, alias, generateEnumValueName( name, prefix, postfix, bitmask, tag ) );
+  enumData.addEnumAlias( line, name, alias );
 }
 
 void VulkanHppGenerator::readEnumConstant( tinyxml2::XMLElement const * element )
@@ -12876,14 +12866,15 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
     check( !type.empty(), line, "enum without type" );
 
     // get the EnumData entry in enum map
-    std::map<std::string, EnumData>::iterator it = m_enums.find( name );
-    check( it != m_enums.end(), line, "enum <" + name + "> is not listed as enum in the types section" );
-    check( it->second.values.empty(), line, "enum <" + name + "> already holds values" );
+    std::map<std::string, EnumData>::iterator enumIt = m_enums.find( name );
+    check( enumIt != m_enums.end(), line, "enum <" + name + "> is not listed as enum in the types section" );
+    check( enumIt->second.values.empty(), line, "enum <" + name + "> already holds values" );
 
     // mark it as a bitmask, if it is one
     bool bitmask = ( type == "bitmask" );
     if ( bitmask )
     {
+      check( name.find( "FlagBits" ) != std::string::npos, line, "bitmask <" + name + "> does not contain <FlagBits>" );
       auto bitmaskIt = std::find_if( m_bitmasks.begin(),
                                      m_bitmasks.end(),
                                      [&name]( auto const & bitmask ) { return bitmask.second.requirements == name; } );
@@ -12895,10 +12886,8 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
              "enum <" + name + "> is marked with bitwidth <64> but corresponding bitmask <" + bitmaskIt->first +
                "> is not of type <VkFlags64>" );
     }
-    it->second.isBitmask = bitmask;
+    enumIt->second.isBitmask = bitmask;
 
-    std::string prefix  = getEnumPrefix( line, name, bitmask );
-    std::string postfix = getEnumPostfix( name, m_tags, prefix );
     // read the names of the enum values
     for ( auto child : children )
     {
@@ -12909,7 +12898,7 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
       }
       else if ( value == "enum" )
       {
-        readEnum( child, it->second, bitmask, prefix, postfix );
+        readEnum( child, enumIt );
       }
     }
   }
@@ -13031,7 +13020,7 @@ void VulkanHppGenerator::readExtension( tinyxml2::XMLElement const * element )
 
     for ( auto child : children )
     {
-      readExtensionRequire( child, pitb.first, tag );
+      readExtensionRequire( child, pitb.first );
     }
   }
 }
@@ -13144,8 +13133,7 @@ void VulkanHppGenerator::readExtensionDisabledType( tinyxml2::XMLElement const *
 }
 
 void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const *                   element,
-                                               std::map<std::string, ExtensionData>::iterator extensionIt,
-                                               std::string const &                            tag )
+                                               std::map<std::string, ExtensionData>::iterator extensionIt )
 {
   int                                line       = element->GetLineNum();
   std::map<std::string, std::string> attributes = getAttributes( element );
@@ -13182,7 +13170,7 @@ void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const *
     }
     else if ( value == "enum" )
     {
-      readRequireEnum( child, extensionIt->first, tag );
+      readRequireEnum( child, extensionIt->first );
     }
     else if ( value == "type" )
     {
@@ -13340,7 +13328,7 @@ void VulkanHppGenerator::readFeatureRequire( tinyxml2::XMLElement const *
     }
     else if ( value == "enum" )
     {
-      readRequireEnum( child, "", "" );
+      readRequireEnum( child, "" );
     }
     else if ( value == "type" )
     {
@@ -13697,25 +13685,22 @@ void VulkanHppGenerator::readRegistry( tinyxml2::XMLElement const * element )
   }
 }
 
-void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element,
-                                          std::string const &          extension,
-                                          std::string const &          tag )
+void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extension )
 {
   std::map<std::string, std::string> attributes = getAttributes( element );
   if ( attributes.find( "alias" ) != attributes.end() )
   {
-    readRequireEnumAlias( element, attributes, tag );
+    readRequireEnumAlias( element, attributes );
   }
   else
   {
-    readRequireEnum( element, attributes, extension, tag );
+    readRequireEnum( element, attributes, extension );
   }
 }
 
 void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *               element,
                                           std::map<std::string, std::string> const & attributes,
-                                          std::string const &                        extension,
-                                          std::string const &                        tag )
+                                          std::string const &                        extension )
 {
   int line = element->GetLineNum();
   checkAttributes( line,
@@ -13773,16 +13758,12 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
     auto enumIt = m_enums.find( extends );
     check( enumIt != m_enums.end(), line, "feature extends unknown enum <" + extends + ">" );
 
-    std::string prefix  = getEnumPrefix( element->GetLineNum(), enumIt->first, enumIt->second.isBitmask );
-    std::string postfix = getEnumPostfix( enumIt->first, m_tags, prefix );
-
     // add this enum name to the list of values
     check( bitpos.empty() + offset.empty() + value.empty() == 2,
            line,
            "exactly one out of bitpos = <" + bitpos + ">, offset = <" + offset + ">, and value = <" + value +
              "> are supposed to be empty" );
-    enumIt->second.addEnumValue(
-      element->GetLineNum(), name, enumIt->second.isBitmask, !bitpos.empty(), prefix, postfix, extension, tag );
+    enumIt->second.addEnumValue( element->GetLineNum(), name, !bitpos.empty(), extension );
   }
   else if ( value.empty() )
   {
@@ -13791,8 +13772,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
 }
 
 void VulkanHppGenerator::readRequireEnumAlias( tinyxml2::XMLElement const *               element,
-                                               std::map<std::string, std::string> const & attributes,
-                                               std::string const &                        tag )
+                                               std::map<std::string, std::string> const & attributes )
 {
   int line = element->GetLineNum();
   checkAttributes( line, attributes, { { "alias", {} }, { "extends", {} }, { "name", {} } }, { { "comment", {} } } );
@@ -13818,22 +13798,8 @@ void VulkanHppGenerator::readRequireEnumAlias( tinyxml2::XMLElement const *
   auto enumIt = m_enums.find( extends );
   check( enumIt != m_enums.end(), line, "feature extends unknown enum <" + extends + ">" );
 
-  std::string prefix  = getEnumPrefix( element->GetLineNum(), enumIt->first, enumIt->second.isBitmask );
-  std::string postfix = getEnumPostfix( enumIt->first, m_tags, prefix );
-
   // add this enum name to the list of aliases
-  std::string valueName = generateEnumValueName( name, prefix, postfix, enumIt->second.isBitmask, tag );
-  if ( !enumIt->second.alias.empty() )
-  {
-    prefix  = getEnumPrefix( element->GetLineNum(), enumIt->second.alias, enumIt->second.isBitmask );
-    postfix = getEnumPostfix( enumIt->second.alias, m_tags, prefix );
-    if ( endsWith( name, postfix ) )
-    {
-      valueName = generateEnumValueName( name, prefix, postfix, enumIt->second.isBitmask, tag );
-    }
-  }
-
-  enumIt->second.addEnumAlias( line, name, alias, valueName );
+  enumIt->second.addEnumAlias( line, name, alias );
 }
 
 void VulkanHppGenerator::readRequires( tinyxml2::XMLElement const *               element,
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 0256fce..13fd9b3 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -132,48 +132,29 @@ private:
 
   struct EnumAliasData
   {
-    EnumAliasData( std::string const & name_, std::string const & translatedName_, int line )
-      : name( name_ ), translatedName( translatedName_ ), xmlLine( line )
-    {}
+    EnumAliasData( std::string const & name_, int line ) : name( name_ ), xmlLine( line ) {}
 
-    std::string name;            // the original name
-    std::string translatedName;  // the name translated into vk-namespace
+    std::string name;
     int         xmlLine;
   };
 
   struct EnumValueData
   {
-    EnumValueData( int                 line,
-                   std::string const & name_,
-                   std::string const & extension_,
-                   bool                singleBit_,
-                   std::string const & translatedName_ )
-      : name( name_ )
-      , extension( extension_ )
-      , singleBit( singleBit_ )
-      , translatedName( translatedName_ )
-      , xmlLine( line )
+    EnumValueData( int line, std::string const & name_, std::string const & extension_, bool singleBit_ )
+      : name( name_ ), extension( extension_ ), singleBit( singleBit_ ), xmlLine( line )
     {}
 
-    std::string name;  // the original name
+    std::string name;
     std::string extension;
     bool        singleBit;
-    std::string translatedName;  // the name translated into vk-namespace
     int         xmlLine;
   };
 
   struct EnumData
   {
     EnumData( int line ) : xmlLine( line ) {}
-    void addEnumAlias( int line, std::string const & name, std::string const & alias, std::string const & vkName );
-    void addEnumValue( int                 line,
-                       std::string const & valueName,
-                       bool                bitmask,
-                       bool                bitpos,
-                       std::string const & prefix,
-                       std::string const & postfix,
-                       std::string const & extension,
-                       std::string const & tag );
+    void addEnumAlias( int line, std::string const & name, std::string const & alias );
+    void addEnumValue( int line, std::string const & valueName, bool bitpos, std::string const & extension );
 
     std::string                          alias;  // alias for this enum
     std::map<std::string, EnumAliasData> aliases;
@@ -519,7 +500,8 @@ private:
   void        appendEnumInitializer( std::string &                      str,
                                      TypeInfo const &                   type,
                                      std::vector<std::string> const &   arraySizes,
-                                     std::vector<EnumValueData> const & values ) const;
+                                     std::vector<EnumValueData> const & values,
+                                     bool                               bitmask ) const;
   void        appendEnumToString( std::string & str, std::pair<std::string, EnumData> const & enumData ) const;
   std::string appendFunctionBodyEnhancedLocalReturnVariable( std::string &       str,
                                                              std::string const & indentation,
@@ -1123,7 +1105,6 @@ private:
                                  std::string const &                                          structName,
                                  std::string const &                                          prefix,
                                  bool mutualExclusiveLens ) const;
-  std::string getEnumPrefix( int line, std::string const & name, bool bitmask ) const;
   std::string getPlatform( std::string const & extension ) const;
   std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const;
   std::string                         getVectorSize( std::vector<ParamData> const &   params,
@@ -1150,23 +1131,13 @@ private:
   void                                readCommands( tinyxml2::XMLElement const * element );
   std::string                         readComment( tinyxml2::XMLElement const * element );
   void readDefine( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
-  void readEnum( tinyxml2::XMLElement const * element,
-                 EnumData &                   enumData,
-                 bool                         bitmask,
-                 std::string const &          prefix,
-                 std::string const &          postfix );
+  void readEnum( tinyxml2::XMLElement const * element, std::map<std::string, EnumData>::iterator enumIt );
   void readEnum( tinyxml2::XMLElement const *               element,
                  std::map<std::string, std::string> const & attributes,
-                 EnumData &                                 enumData,
-                 bool                                       bitmask,
-                 std::string const &                        prefix,
-                 std::string const &                        postfix );
+                 std::map<std::string, EnumData>::iterator  enumIt );
   void readEnumAlias( tinyxml2::XMLElement const *               element,
                       std::map<std::string, std::string> const & attributes,
-                      EnumData &                                 enumData,
-                      bool                                       bitmask,
-                      std::string const &                        prefix,
-                      std::string const &                        postfix );
+                      EnumData &                                 enumData );
   void readEnumConstant( tinyxml2::XMLElement const * element );
   void readEnums( tinyxml2::XMLElement const * element );
   void readExtension( tinyxml2::XMLElement const * element );
@@ -1174,8 +1145,7 @@ private:
   void readExtensionDisabledRequire( tinyxml2::XMLElement const * element );
   void readExtensionDisabledType( tinyxml2::XMLElement const * element );
   void readExtensionRequire( tinyxml2::XMLElement const *                   element,
-                             std::map<std::string, ExtensionData>::iterator extensionIt,
-                             std::string const &                            tag );
+                             std::map<std::string, ExtensionData>::iterator extensionIt );
   void readExtensionRequireCommand( tinyxml2::XMLElement const *                   element,
                                     std::map<std::string, ExtensionData>::iterator extensionIt );
   void readExtensionRequireType( tinyxml2::XMLElement const *                   element,
@@ -1194,14 +1164,12 @@ private:
   void                          readPlatform( tinyxml2::XMLElement const * element );
   void                          readPlatforms( tinyxml2::XMLElement const * element );
   void                          readRegistry( tinyxml2::XMLElement const * element );
-  void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extension, std::string const & tag );
-  void readRequireEnum( tinyxml2::XMLElement const *               element,
-                        std::map<std::string, std::string> const & attributes,
-                        std::string const &                        extension,
-                        std::string const &                        tag );
-  void readRequireEnumAlias( tinyxml2::XMLElement const *               element,
-                             std::map<std::string, std::string> const & attributes,
-                             std::string const &                        tag );
+  void                          readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extension );
+  void                          readRequireEnum( tinyxml2::XMLElement const *               element,
+                                                 std::map<std::string, std::string> const & attributes,
+                                                 std::string const &                        extension );
+  void                          readRequireEnumAlias( tinyxml2::XMLElement const *               element,
+                                                      std::map<std::string, std::string> const & attributes );
   void readRequires( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
   void readSPIRVCapability( tinyxml2::XMLElement const * element );
   void readSPIRVCapabilityEnable( tinyxml2::XMLElement const * element );
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 2f8dbf0..31b0782 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -6394,8 +6394,8 @@ namespace VULKAN_HPP_NAMESPACE
     eSemaphoreSubmitInfoKHR                    = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR,
     eCommandBufferSubmitInfoKHR                = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR,
     ePhysicalDeviceSynchronization2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR,
-    eQueueFamilyCheckpointProperties2Nv        = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
-    eCheckpointData2Nv                         = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV,
+    eQueueFamilyCheckpointProperties2NV        = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
+    eCheckpointData2NV                         = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV,
     ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR =
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR,
     ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV =
@@ -7269,8 +7269,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eCommandBufferSubmitInfoKHR: return "CommandBufferSubmitInfoKHR";
       case StructureType::ePhysicalDeviceSynchronization2FeaturesKHR:
         return "PhysicalDeviceSynchronization2FeaturesKHR";
-      case StructureType::eQueueFamilyCheckpointProperties2Nv: return "QueueFamilyCheckpointProperties2Nv";
-      case StructureType::eCheckpointData2Nv: return "CheckpointData2Nv";
+      case StructureType::eQueueFamilyCheckpointProperties2NV: return "QueueFamilyCheckpointProperties2NV";
+      case StructureType::eCheckpointData2NV: return "CheckpointData2NV";
       case StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR:
         return "PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR";
       case StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV:
@@ -10521,8 +10521,7 @@ namespace VULKAN_HPP_NAMESPACE
     eMesaLlvmpipe            = VK_DRIVER_ID_MESA_LLVMPIPE,
     eMoltenvk                = VK_DRIVER_ID_MOLTENVK,
     eCoreaviProprietary      = VK_DRIVER_ID_COREAVI_PROPRIETARY,
-    eJuiceProprietary        = VK_DRIVER_ID_JUICE_PROPRIETARY,
-    eIntelOpenSourceMesa     = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR
+    eJuiceProprietary        = VK_DRIVER_ID_JUICE_PROPRIETARY
   };
   using DriverIdKHR = DriverId;
 
@@ -12641,18 +12640,18 @@ namespace VULKAN_HPP_NAMESPACE
     eVideoDecode = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
     eVideoEncode = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR,
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    eTransformFeedbackExt          = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT,
-    eConditionalRenderingExt       = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT,
-    eCommandPreprocessNv           = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV,
+    eTransformFeedbackEXT          = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT,
+    eConditionalRenderingEXT       = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT,
+    eCommandPreprocessNV           = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV,
     eFragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
     eAccelerationStructureBuild    = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
     eRayTracingShader              = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR,
-    eFragmentDensityProcessExt     = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
-    eTaskShaderNv                  = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV,
-    eMeshShaderNv                  = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
-    eAccelerationStructureBuildNv  = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
-    eRayTracingShaderNv            = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV,
-    eShadingRateImageNv            = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV,
+    eFragmentDensityProcessEXT     = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
+    eTaskShaderNV                  = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV,
+    eMeshShaderNV                  = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
+    eAccelerationStructureBuildNV  = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
+    eRayTracingShaderNV            = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV,
+    eShadingRateImageNV            = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV,
     eTransfer                      = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR
   };
 
@@ -12689,15 +12688,15 @@ namespace VULKAN_HPP_NAMESPACE
       case PipelineStageFlagBits2KHR::eVideoDecode: return "VideoDecode";
       case PipelineStageFlagBits2KHR::eVideoEncode: return "VideoEncode";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      case PipelineStageFlagBits2KHR::eTransformFeedbackExt: return "TransformFeedbackExt";
-      case PipelineStageFlagBits2KHR::eConditionalRenderingExt: return "ConditionalRenderingExt";
-      case PipelineStageFlagBits2KHR::eCommandPreprocessNv: return "CommandPreprocessNv";
+      case PipelineStageFlagBits2KHR::eTransformFeedbackEXT: return "TransformFeedbackEXT";
+      case PipelineStageFlagBits2KHR::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
+      case PipelineStageFlagBits2KHR::eCommandPreprocessNV: return "CommandPreprocessNV";
       case PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment";
       case PipelineStageFlagBits2KHR::eAccelerationStructureBuild: return "AccelerationStructureBuild";
       case PipelineStageFlagBits2KHR::eRayTracingShader: return "RayTracingShader";
-      case PipelineStageFlagBits2KHR::eFragmentDensityProcessExt: return "FragmentDensityProcessExt";
-      case PipelineStageFlagBits2KHR::eTaskShaderNv: return "TaskShaderNv";
-      case PipelineStageFlagBits2KHR::eMeshShaderNv: return "MeshShaderNv";
+      case PipelineStageFlagBits2KHR::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
+      case PipelineStageFlagBits2KHR::eTaskShaderNV: return "TaskShaderNV";
+      case PipelineStageFlagBits2KHR::eMeshShaderNV: return "MeshShaderNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -12731,20 +12730,20 @@ namespace VULKAN_HPP_NAMESPACE
     eVideoEncodeRead  = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR,
     eVideoEncodeWrite = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR,
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    eTransformFeedbackWriteExt         = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
-    eTransformFeedbackCounterReadExt   = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
-    eTransformFeedbackCounterWriteExt  = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
-    eConditionalRenderingReadExt       = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT,
-    eCommandPreprocessReadNv           = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV,
-    eCommandPreprocessWriteNv          = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV,
+    eTransformFeedbackWriteEXT         = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+    eTransformFeedbackCounterReadEXT   = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
+    eTransformFeedbackCounterWriteEXT  = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+    eConditionalRenderingReadEXT       = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT,
+    eCommandPreprocessReadNV           = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV,
+    eCommandPreprocessWriteNV          = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV,
     eFragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
     eAccelerationStructureRead         = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR,
     eAccelerationStructureWrite        = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
-    eFragmentDensityMapReadExt         = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
-    eColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
-    eAccelerationStructureReadNv       = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV,
-    eAccelerationStructureWriteNv      = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
-    eShadingRateImageReadNv            = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV
+    eFragmentDensityMapReadEXT         = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
+    eColorAttachmentReadNoncoherentEXT = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
+    eAccelerationStructureReadNV       = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV,
+    eAccelerationStructureWriteNV      = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
+    eShadingRateImageReadNV            = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV
   };
 
   VULKAN_HPP_INLINE std::string to_string( AccessFlagBits2KHR value )
@@ -12778,17 +12777,17 @@ namespace VULKAN_HPP_NAMESPACE
       case AccessFlagBits2KHR::eVideoEncodeRead: return "VideoEncodeRead";
       case AccessFlagBits2KHR::eVideoEncodeWrite: return "VideoEncodeWrite";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      case AccessFlagBits2KHR::eTransformFeedbackWriteExt: return "TransformFeedbackWriteExt";
-      case AccessFlagBits2KHR::eTransformFeedbackCounterReadExt: return "TransformFeedbackCounterReadExt";
-      case AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt: return "TransformFeedbackCounterWriteExt";
-      case AccessFlagBits2KHR::eConditionalRenderingReadExt: return "ConditionalRenderingReadExt";
-      case AccessFlagBits2KHR::eCommandPreprocessReadNv: return "CommandPreprocessReadNv";
-      case AccessFlagBits2KHR::eCommandPreprocessWriteNv: return "CommandPreprocessWriteNv";
+      case AccessFlagBits2KHR::eTransformFeedbackWriteEXT: return "TransformFeedbackWriteEXT";
+      case AccessFlagBits2KHR::eTransformFeedbackCounterReadEXT: return "TransformFeedbackCounterReadEXT";
+      case AccessFlagBits2KHR::eTransformFeedbackCounterWriteEXT: return "TransformFeedbackCounterWriteEXT";
+      case AccessFlagBits2KHR::eConditionalRenderingReadEXT: return "ConditionalRenderingReadEXT";
+      case AccessFlagBits2KHR::eCommandPreprocessReadNV: return "CommandPreprocessReadNV";
+      case AccessFlagBits2KHR::eCommandPreprocessWriteNV: return "CommandPreprocessWriteNV";
       case AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead: return "FragmentShadingRateAttachmentRead";
       case AccessFlagBits2KHR::eAccelerationStructureRead: return "AccelerationStructureRead";
       case AccessFlagBits2KHR::eAccelerationStructureWrite: return "AccelerationStructureWrite";
-      case AccessFlagBits2KHR::eFragmentDensityMapReadExt: return "FragmentDensityMapReadExt";
-      case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt: return "ColorAttachmentReadNoncoherentExt";
+      case AccessFlagBits2KHR::eFragmentDensityMapReadEXT: return "FragmentDensityMapReadEXT";
+      case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -19193,14 +19192,14 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
         | VkFlags64( PipelineStageFlagBits2KHR::eVideoDecode ) | VkFlags64( PipelineStageFlagBits2KHR::eVideoEncode )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        | VkFlags64( PipelineStageFlagBits2KHR::eTransformFeedbackExt ) |
-        VkFlags64( PipelineStageFlagBits2KHR::eConditionalRenderingExt ) |
-        VkFlags64( PipelineStageFlagBits2KHR::eCommandPreprocessNv ) |
+        | VkFlags64( PipelineStageFlagBits2KHR::eTransformFeedbackEXT ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eConditionalRenderingEXT ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eCommandPreprocessNV ) |
         VkFlags64( PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment ) |
         VkFlags64( PipelineStageFlagBits2KHR::eAccelerationStructureBuild ) |
         VkFlags64( PipelineStageFlagBits2KHR::eRayTracingShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::eFragmentDensityProcessExt ) |
-        VkFlags64( PipelineStageFlagBits2KHR::eTaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::eMeshShaderNv )
+        VkFlags64( PipelineStageFlagBits2KHR::eFragmentDensityProcessEXT ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eTaskShaderNV ) | VkFlags64( PipelineStageFlagBits2KHR::eMeshShaderNV )
     };
   };
 
@@ -19290,24 +19289,24 @@ namespace VULKAN_HPP_NAMESPACE
     if ( value & PipelineStageFlagBits2KHR::eVideoEncode )
       result += "VideoEncode | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    if ( value & PipelineStageFlagBits2KHR::eTransformFeedbackExt )
-      result += "TransformFeedbackExt | ";
-    if ( value & PipelineStageFlagBits2KHR::eConditionalRenderingExt )
-      result += "ConditionalRenderingExt | ";
-    if ( value & PipelineStageFlagBits2KHR::eCommandPreprocessNv )
-      result += "CommandPreprocessNv | ";
+    if ( value & PipelineStageFlagBits2KHR::eTransformFeedbackEXT )
+      result += "TransformFeedbackEXT | ";
+    if ( value & PipelineStageFlagBits2KHR::eConditionalRenderingEXT )
+      result += "ConditionalRenderingEXT | ";
+    if ( value & PipelineStageFlagBits2KHR::eCommandPreprocessNV )
+      result += "CommandPreprocessNV | ";
     if ( value & PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment )
       result += "FragmentShadingRateAttachment | ";
     if ( value & PipelineStageFlagBits2KHR::eAccelerationStructureBuild )
       result += "AccelerationStructureBuild | ";
     if ( value & PipelineStageFlagBits2KHR::eRayTracingShader )
       result += "RayTracingShader | ";
-    if ( value & PipelineStageFlagBits2KHR::eFragmentDensityProcessExt )
-      result += "FragmentDensityProcessExt | ";
-    if ( value & PipelineStageFlagBits2KHR::eTaskShaderNv )
-      result += "TaskShaderNv | ";
-    if ( value & PipelineStageFlagBits2KHR::eMeshShaderNv )
-      result += "MeshShaderNv | ";
+    if ( value & PipelineStageFlagBits2KHR::eFragmentDensityProcessEXT )
+      result += "FragmentDensityProcessEXT | ";
+    if ( value & PipelineStageFlagBits2KHR::eTaskShaderNV )
+      result += "TaskShaderNV | ";
+    if ( value & PipelineStageFlagBits2KHR::eMeshShaderNV )
+      result += "MeshShaderNV | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -19334,17 +19333,17 @@ namespace VULKAN_HPP_NAMESPACE
         | VkFlags64( AccessFlagBits2KHR::eVideoDecodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoDecodeWrite ) |
         VkFlags64( AccessFlagBits2KHR::eVideoEncodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoEncodeWrite )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        | VkFlags64( AccessFlagBits2KHR::eTransformFeedbackWriteExt ) |
-        VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) |
-        VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) |
-        VkFlags64( AccessFlagBits2KHR::eConditionalRenderingReadExt ) |
-        VkFlags64( AccessFlagBits2KHR::eCommandPreprocessReadNv ) |
-        VkFlags64( AccessFlagBits2KHR::eCommandPreprocessWriteNv ) |
+        | VkFlags64( AccessFlagBits2KHR::eTransformFeedbackWriteEXT ) |
+        VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterReadEXT ) |
+        VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterWriteEXT ) |
+        VkFlags64( AccessFlagBits2KHR::eConditionalRenderingReadEXT ) |
+        VkFlags64( AccessFlagBits2KHR::eCommandPreprocessReadNV ) |
+        VkFlags64( AccessFlagBits2KHR::eCommandPreprocessWriteNV ) |
         VkFlags64( AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead ) |
         VkFlags64( AccessFlagBits2KHR::eAccelerationStructureRead ) |
         VkFlags64( AccessFlagBits2KHR::eAccelerationStructureWrite ) |
-        VkFlags64( AccessFlagBits2KHR::eFragmentDensityMapReadExt ) |
-        VkFlags64( AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt )
+        VkFlags64( AccessFlagBits2KHR::eFragmentDensityMapReadEXT ) |
+        VkFlags64( AccessFlagBits2KHR::eColorAttachmentReadNoncoherentEXT )
     };
   };
 
@@ -19433,28 +19432,28 @@ namespace VULKAN_HPP_NAMESPACE
     if ( value & AccessFlagBits2KHR::eVideoEncodeWrite )
       result += "VideoEncodeWrite | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    if ( value & AccessFlagBits2KHR::eTransformFeedbackWriteExt )
-      result += "TransformFeedbackWriteExt | ";
-    if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterReadExt )
-      result += "TransformFeedbackCounterReadExt | ";
-    if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt )
-      result += "TransformFeedbackCounterWriteExt | ";
-    if ( value & AccessFlagBits2KHR::eConditionalRenderingReadExt )
-      result += "ConditionalRenderingReadExt | ";
-    if ( value & AccessFlagBits2KHR::eCommandPreprocessReadNv )
-      result += "CommandPreprocessReadNv | ";
-    if ( value & AccessFlagBits2KHR::eCommandPreprocessWriteNv )
-      result += "CommandPreprocessWriteNv | ";
+    if ( value & AccessFlagBits2KHR::eTransformFeedbackWriteEXT )
+      result += "TransformFeedbackWriteEXT | ";
+    if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterReadEXT )
+      result += "TransformFeedbackCounterReadEXT | ";
+    if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteEXT )
+      result += "TransformFeedbackCounterWriteEXT | ";
+    if ( value & AccessFlagBits2KHR::eConditionalRenderingReadEXT )
+      result += "ConditionalRenderingReadEXT | ";
+    if ( value & AccessFlagBits2KHR::eCommandPreprocessReadNV )
+      result += "CommandPreprocessReadNV | ";
+    if ( value & AccessFlagBits2KHR::eCommandPreprocessWriteNV )
+      result += "CommandPreprocessWriteNV | ";
     if ( value & AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead )
       result += "FragmentShadingRateAttachmentRead | ";
     if ( value & AccessFlagBits2KHR::eAccelerationStructureRead )
       result += "AccelerationStructureRead | ";
     if ( value & AccessFlagBits2KHR::eAccelerationStructureWrite )
       result += "AccelerationStructureWrite | ";
-    if ( value & AccessFlagBits2KHR::eFragmentDensityMapReadExt )
-      result += "FragmentDensityMapReadExt | ";
-    if ( value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt )
-      result += "ColorAttachmentReadNoncoherentExt | ";
+    if ( value & AccessFlagBits2KHR::eFragmentDensityMapReadEXT )
+      result += "FragmentDensityMapReadEXT | ";
+    if ( value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentEXT )
+      result += "ColorAttachmentReadNoncoherentEXT | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -29108,7 +29107,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CheckpointData2NV
   {
     static const bool                                  allowDuplicate = false;
-    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCheckpointData2Nv;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCheckpointData2NV;
 
 #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
     VULKAN_HPP_CONSTEXPR CheckpointData2NV( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage_ = {},
@@ -29159,7 +29158,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType          sType             = StructureType::eCheckpointData2Nv;
+    VULKAN_HPP_NAMESPACE::StructureType          sType             = StructureType::eCheckpointData2NV;
     void *                                       pNext             = {};
     VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage             = {};
     void *                                       pCheckpointMarker = {};
@@ -29169,7 +29168,7 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( std::is_standard_layout<CheckpointData2NV>::value, "struct wrapper is not a standard layout!" );
 
   template <>
-  struct CppType<StructureType, StructureType::eCheckpointData2Nv>
+  struct CppType<StructureType, StructureType::eCheckpointData2NV>
   {
     using Type = CheckpointData2NV;
   };
@@ -93488,7 +93487,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     static const bool                                  allowDuplicate = false;
     static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
-      StructureType::eQueueFamilyCheckpointProperties2Nv;
+      StructureType::eQueueFamilyCheckpointProperties2NV;
 
 #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
     VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointProperties2NV(
@@ -93540,7 +93539,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType          sType = StructureType::eQueueFamilyCheckpointProperties2Nv;
+    VULKAN_HPP_NAMESPACE::StructureType          sType = StructureType::eQueueFamilyCheckpointProperties2NV;
     void *                                       pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR checkpointExecutionStageMask = {};
   };
@@ -93550,7 +93549,7 @@ namespace VULKAN_HPP_NAMESPACE
                  "struct wrapper is not a standard layout!" );
 
   template <>
-  struct CppType<StructureType, StructureType::eQueueFamilyCheckpointProperties2Nv>
+  struct CppType<StructureType, StructureType::eQueueFamilyCheckpointProperties2NV>
   {
     using Type = QueueFamilyCheckpointProperties2NV;
   };