Steam: ClientHello packet sending

25 files changed, 23130 insertions, 6 deletions

diff --git a/protocols/Steam/Steam.vcxproj b/protocols/Steam/Steam.vcxproj
index f1ae37c2ef..b93833d00b 100644
--- a/protocols/Steam/Steam.vcxproj
+++ b/protocols/Steam/Steam.vcxproj
@@ -27,6 +27,24 @@
   </ImportGroup>

   <ItemGroup>

     <ClCompile Include="src\main.cpp" />

+    <ClCompile Include="src\protobuf-c\enums.pb-c.cpp">

+      <PrecompiledHeader>NotUsing</PrecompiledHeader>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\protobuf-c.c">

+      <PrecompiledHeader>NotUsing</PrecompiledHeader>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_auth.steamclient.pb-c.cpp">

+      <PrecompiledHeader>NotUsing</PrecompiledHeader>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_base.pb-c.cpp">

+      <PrecompiledHeader>NotUsing</PrecompiledHeader>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_clientserver_login.pb-c.cpp">

+      <PrecompiledHeader>NotUsing</PrecompiledHeader>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_unified_base.steamclient.pb-c.cpp">

+      <PrecompiledHeader>NotUsing</PrecompiledHeader>

+    </ClCompile>

     <ClCompile Include="src\stdafx.cxx">

       <PrecompiledHeader>Create</PrecompiledHeader>

     </ClCompile>

@@ -60,6 +78,11 @@
     <ClInclude Include="src\api\search.h" />

     <ClInclude Include="src\api\session.h" />

     <ClInclude Include="src\http_request.h" />

+    <ClInclude Include="src\protobuf-c\enums.pb-c.h" />

+    <ClInclude Include="src\protobuf-c\steammessages_auth.steamclient.pb-c.h" />

+    <ClInclude Include="src\protobuf-c\steammessages_base.pb-c.h" />

+    <ClInclude Include="src\protobuf-c\steammessages_clientserver_login.pb-c.h" />

+    <ClInclude Include="src\protobuf-c\steammessages_unified_base.steamclient.pb-c.h" />

     <ClInclude Include="src\resource.h" />

     <ClInclude Include="src\stdafx.h" />

     <ClInclude Include="src\steam_dialogs.h" />

@@ -80,6 +103,7 @@
   <ItemDefinitionGroup>

     <ClCompile>

       <LanguageStandard>stdcpp17</LanguageStandard>

+      <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

     </ClCompile>

   </ItemDefinitionGroup>

 </Project>
\ No newline at end of file
diff --git a/protocols/Steam/Steam.vcxproj.filters b/protocols/Steam/Steam.vcxproj.filters
index 14a7b387ee..41c7de37fb 100644
--- a/protocols/Steam/Steam.vcxproj.filters
+++ b/protocols/Steam/Steam.vcxproj.filters
@@ -4,6 +4,9 @@
     <Filter Include="Header Files\api">

       <UniqueIdentifier>{f07fed5a-9010-4d64-9586-bdf123a38be8}</UniqueIdentifier>

     </Filter>

+    <Filter Include="Source Files\protobuf">

+      <UniqueIdentifier>{bd3e8143-14ec-48be-9951-3882851e8716}</UniqueIdentifier>

+    </Filter>

   </ItemGroup>

   <ItemGroup>

     <ClCompile Include="src\main.cpp">

@@ -57,6 +60,24 @@
     <ClCompile Include="src\steam_server.cpp">

       <Filter>Source Files</Filter>

     </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_clientserver_login.pb-c.cpp">

+      <Filter>Source Files\protobuf</Filter>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_base.pb-c.cpp">

+      <Filter>Source Files\protobuf</Filter>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\protobuf-c.c">

+      <Filter>Source Files\protobuf</Filter>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_auth.steamclient.pb-c.cpp">

+      <Filter>Source Files\protobuf</Filter>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\steammessages_unified_base.steamclient.pb-c.cpp">

+      <Filter>Source Files\protobuf</Filter>

+    </ClCompile>

+    <ClCompile Include="src\protobuf-c\enums.pb-c.cpp">

+      <Filter>Source Files\protobuf</Filter>

+    </ClCompile>

   </ItemGroup>

   <ItemGroup>

     <ClInclude Include="src\http_request.h">

@@ -119,6 +140,21 @@
     <ClInclude Include="src\api\session.h">

       <Filter>Header Files\api</Filter>

     </ClInclude>

+    <ClInclude Include="src\protobuf-c\steammessages_clientserver_login.pb-c.h">

+      <Filter>Source Files\protobuf</Filter>

+    </ClInclude>

+    <ClInclude Include="src\protobuf-c\steammessages_base.pb-c.h">

+      <Filter>Source Files\protobuf</Filter>

+    </ClInclude>

+    <ClInclude Include="src\protobuf-c\steammessages_auth.steamclient.pb-c.h">

+      <Filter>Source Files\protobuf</Filter>

+    </ClInclude>

+    <ClInclude Include="src\protobuf-c\steammessages_unified_base.steamclient.pb-c.h">

+      <Filter>Source Files\protobuf</Filter>

+    </ClInclude>

+    <ClInclude Include="src\protobuf-c\enums.pb-c.h">

+      <Filter>Source Files\protobuf</Filter>

+    </ClInclude>

   </ItemGroup>

   <ItemGroup>

     <ResourceCompile Include="res\Resource.rc">

diff --git a/protocols/Steam/src/protobuf-c/enums.pb-c.cpp b/protocols/Steam/src/protobuf-c/enums.pb-c.cpp
new file mode 100644
index 0000000000..56b0426a6f
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/enums.pb-c.cpp
@@ -0,0 +1,1519 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: enums.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "enums.pb-c.h"
+static const ProtobufCEnumValue epublished_file_query_type__enum_values_by_number[22] =
+{
+  { "k_PublishedFileQueryType_RankedByVote", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByVote", 0 },
+  { "k_PublishedFileQueryType_RankedByPublicationDate", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByPublicationDate", 1 },
+  { "k_PublishedFileQueryType_AcceptedForGameRankedByAcceptanceDate", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_AcceptedForGameRankedByAcceptanceDate", 2 },
+  { "k_PublishedFileQueryType_RankedByTrend", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTrend", 3 },
+  { "k_PublishedFileQueryType_FavoritedByFriendsRankedByPublicationDate", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_FavoritedByFriendsRankedByPublicationDate", 4 },
+  { "k_PublishedFileQueryType_CreatedByFriendsRankedByPublicationDate", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_CreatedByFriendsRankedByPublicationDate", 5 },
+  { "k_PublishedFileQueryType_RankedByNumTimesReported", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByNumTimesReported", 6 },
+  { "k_PublishedFileQueryType_CreatedByFollowedUsersRankedByPublicationDate", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_CreatedByFollowedUsersRankedByPublicationDate", 7 },
+  { "k_PublishedFileQueryType_NotYetRated", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_NotYetRated", 8 },
+  { "k_PublishedFileQueryType_RankedByTotalUniqueSubscriptions", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTotalUniqueSubscriptions", 9 },
+  { "k_PublishedFileQueryType_RankedByTotalVotesAsc", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTotalVotesAsc", 10 },
+  { "k_PublishedFileQueryType_RankedByVotesUp", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByVotesUp", 11 },
+  { "k_PublishedFileQueryType_RankedByTextSearch", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTextSearch", 12 },
+  { "k_PublishedFileQueryType_RankedByPlaytimeTrend", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByPlaytimeTrend", 13 },
+  { "k_PublishedFileQueryType_RankedByTotalPlaytime", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTotalPlaytime", 14 },
+  { "k_PublishedFileQueryType_RankedByAveragePlaytimeTrend", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByAveragePlaytimeTrend", 15 },
+  { "k_PublishedFileQueryType_RankedByLifetimeAveragePlaytime", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByLifetimeAveragePlaytime", 16 },
+  { "k_PublishedFileQueryType_RankedByPlaytimeSessionsTrend", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByPlaytimeSessionsTrend", 17 },
+  { "k_PublishedFileQueryType_RankedByLifetimePlaytimeSessions", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByLifetimePlaytimeSessions", 18 },
+  { "k_PublishedFileQueryType_RankedByInappropriateContentRating", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByInappropriateContentRating", 19 },
+  { "k_PublishedFileQueryType_RankedByBanContentCheck", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByBanContentCheck", 20 },
+  { "k_PublishedFileQueryType_RankedByLastUpdatedDate", "EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByLastUpdatedDate", 21 },
+};
+static const ProtobufCIntRange epublished_file_query_type__value_ranges[] = {
+{0, 0},{0, 22}
+};
+static const ProtobufCEnumValueIndex epublished_file_query_type__enum_values_by_name[22] =
+{
+  { "k_PublishedFileQueryType_AcceptedForGameRankedByAcceptanceDate", 2 },
+  { "k_PublishedFileQueryType_CreatedByFollowedUsersRankedByPublicationDate", 7 },
+  { "k_PublishedFileQueryType_CreatedByFriendsRankedByPublicationDate", 5 },
+  { "k_PublishedFileQueryType_FavoritedByFriendsRankedByPublicationDate", 4 },
+  { "k_PublishedFileQueryType_NotYetRated", 8 },
+  { "k_PublishedFileQueryType_RankedByAveragePlaytimeTrend", 15 },
+  { "k_PublishedFileQueryType_RankedByBanContentCheck", 20 },
+  { "k_PublishedFileQueryType_RankedByInappropriateContentRating", 19 },
+  { "k_PublishedFileQueryType_RankedByLastUpdatedDate", 21 },
+  { "k_PublishedFileQueryType_RankedByLifetimeAveragePlaytime", 16 },
+  { "k_PublishedFileQueryType_RankedByLifetimePlaytimeSessions", 18 },
+  { "k_PublishedFileQueryType_RankedByNumTimesReported", 6 },
+  { "k_PublishedFileQueryType_RankedByPlaytimeSessionsTrend", 17 },
+  { "k_PublishedFileQueryType_RankedByPlaytimeTrend", 13 },
+  { "k_PublishedFileQueryType_RankedByPublicationDate", 1 },
+  { "k_PublishedFileQueryType_RankedByTextSearch", 12 },
+  { "k_PublishedFileQueryType_RankedByTotalPlaytime", 14 },
+  { "k_PublishedFileQueryType_RankedByTotalUniqueSubscriptions", 9 },
+  { "k_PublishedFileQueryType_RankedByTotalVotesAsc", 10 },
+  { "k_PublishedFileQueryType_RankedByTrend", 3 },
+  { "k_PublishedFileQueryType_RankedByVote", 0 },
+  { "k_PublishedFileQueryType_RankedByVotesUp", 11 },
+};
+const ProtobufCEnumDescriptor epublished_file_query_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EPublishedFileQueryType",
+  "EPublishedFileQueryType",
+  "EPublishedFileQueryType",
+  "",
+  22,
+  epublished_file_query_type__enum_values_by_number,
+  22,
+  epublished_file_query_type__enum_values_by_name,
+  1,
+  epublished_file_query_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue epublished_file_inappropriate_provider__enum_values_by_number[3] =
+{
+  { "k_EPublishedFileInappropriateProvider_Invalid", "EPUBLISHED_FILE_INAPPROPRIATE_PROVIDER__k_EPublishedFileInappropriateProvider_Invalid", 0 },
+  { "k_EPublishedFileInappropriateProvider_Google", "EPUBLISHED_FILE_INAPPROPRIATE_PROVIDER__k_EPublishedFileInappropriateProvider_Google", 1 },
+  { "k_EPublishedFileInappropriateProvider_Amazon", "EPUBLISHED_FILE_INAPPROPRIATE_PROVIDER__k_EPublishedFileInappropriateProvider_Amazon", 2 },
+};
+static const ProtobufCIntRange epublished_file_inappropriate_provider__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex epublished_file_inappropriate_provider__enum_values_by_name[3] =
+{
+  { "k_EPublishedFileInappropriateProvider_Amazon", 2 },
+  { "k_EPublishedFileInappropriateProvider_Google", 1 },
+  { "k_EPublishedFileInappropriateProvider_Invalid", 0 },
+};
+const ProtobufCEnumDescriptor epublished_file_inappropriate_provider__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EPublishedFileInappropriateProvider",
+  "EPublishedFileInappropriateProvider",
+  "EPublishedFileInappropriateProvider",
+  "",
+  3,
+  epublished_file_inappropriate_provider__enum_values_by_number,
+  3,
+  epublished_file_inappropriate_provider__enum_values_by_name,
+  1,
+  epublished_file_inappropriate_provider__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue epublished_file_inappropriate_result__enum_values_by_number[6] =
+{
+  { "k_EPublishedFileInappropriateResult_NotScanned", "EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_NotScanned", 0 },
+  { "k_EPublishedFileInappropriateResult_VeryUnlikely", "EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_VeryUnlikely", 1 },
+  { "k_EPublishedFileInappropriateResult_Unlikely", "EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_Unlikely", 30 },
+  { "k_EPublishedFileInappropriateResult_Possible", "EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_Possible", 50 },
+  { "k_EPublishedFileInappropriateResult_Likely", "EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_Likely", 75 },
+  { "k_EPublishedFileInappropriateResult_VeryLikely", "EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_VeryLikely", 100 },
+};
+static const ProtobufCIntRange epublished_file_inappropriate_result__value_ranges[] = {
+{0, 0},{30, 2},{50, 3},{75, 4},{100, 5},{0, 6}
+};
+static const ProtobufCEnumValueIndex epublished_file_inappropriate_result__enum_values_by_name[6] =
+{
+  { "k_EPublishedFileInappropriateResult_Likely", 4 },
+  { "k_EPublishedFileInappropriateResult_NotScanned", 0 },
+  { "k_EPublishedFileInappropriateResult_Possible", 3 },
+  { "k_EPublishedFileInappropriateResult_Unlikely", 2 },
+  { "k_EPublishedFileInappropriateResult_VeryLikely", 5 },
+  { "k_EPublishedFileInappropriateResult_VeryUnlikely", 1 },
+};
+const ProtobufCEnumDescriptor epublished_file_inappropriate_result__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EPublishedFileInappropriateResult",
+  "EPublishedFileInappropriateResult",
+  "EPublishedFileInappropriateResult",
+  "",
+  6,
+  epublished_file_inappropriate_result__enum_values_by_number,
+  6,
+  epublished_file_inappropriate_result__enum_values_by_name,
+  5,
+  epublished_file_inappropriate_result__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue epersona_state_flag__enum_values_by_number[10] =
+{
+  { "k_EPersonaStateFlag_HasRichPresence", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_HasRichPresence", 1 },
+  { "k_EPersonaStateFlag_InJoinableGame", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_InJoinableGame", 2 },
+  { "k_EPersonaStateFlag_Golden", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_Golden", 4 },
+  { "k_EPersonaStateFlag_RemotePlayTogether", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_RemotePlayTogether", 8 },
+  { "k_EPersonaStateFlag_ClientTypeWeb", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeWeb", 256 },
+  { "k_EPersonaStateFlag_ClientTypeMobile", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeMobile", 512 },
+  { "k_EPersonaStateFlag_ClientTypeTenfoot", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeTenfoot", 1024 },
+  { "k_EPersonaStateFlag_ClientTypeVR", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeVR", 2048 },
+  { "k_EPersonaStateFlag_LaunchTypeGamepad", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_LaunchTypeGamepad", 4096 },
+  { "k_EPersonaStateFlag_LaunchTypeCompatTool", "EPERSONA_STATE_FLAG__k_EPersonaStateFlag_LaunchTypeCompatTool", 8192 },
+};
+static const ProtobufCIntRange epersona_state_flag__value_ranges[] = {
+{1, 0},{4, 2},{8, 3},{256, 4},{512, 5},{1024, 6},{2048, 7},{4096, 8},{8192, 9},{0, 10}
+};
+static const ProtobufCEnumValueIndex epersona_state_flag__enum_values_by_name[10] =
+{
+  { "k_EPersonaStateFlag_ClientTypeMobile", 5 },
+  { "k_EPersonaStateFlag_ClientTypeTenfoot", 6 },
+  { "k_EPersonaStateFlag_ClientTypeVR", 7 },
+  { "k_EPersonaStateFlag_ClientTypeWeb", 4 },
+  { "k_EPersonaStateFlag_Golden", 2 },
+  { "k_EPersonaStateFlag_HasRichPresence", 0 },
+  { "k_EPersonaStateFlag_InJoinableGame", 1 },
+  { "k_EPersonaStateFlag_LaunchTypeCompatTool", 9 },
+  { "k_EPersonaStateFlag_LaunchTypeGamepad", 8 },
+  { "k_EPersonaStateFlag_RemotePlayTogether", 3 },
+};
+const ProtobufCEnumDescriptor epersona_state_flag__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EPersonaStateFlag",
+  "EPersonaStateFlag",
+  "EPersonaStateFlag",
+  "",
+  10,
+  epersona_state_flag__enum_values_by_number,
+  10,
+  epersona_state_flag__enum_values_by_name,
+  9,
+  epersona_state_flag__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue econtent_check_provider__enum_values_by_number[4] =
+{
+  { "k_EContentCheckProvider_Invalid", "ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Invalid", 0 },
+  { "k_EContentCheckProvider_Google", "ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Google", 1 },
+  { "k_EContentCheckProvider_Amazon", "ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Amazon", 2 },
+  { "k_EContentCheckProvider_Local", "ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Local", 3 },
+};
+static const ProtobufCIntRange econtent_check_provider__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex econtent_check_provider__enum_values_by_name[4] =
+{
+  { "k_EContentCheckProvider_Amazon", 2 },
+  { "k_EContentCheckProvider_Google", 1 },
+  { "k_EContentCheckProvider_Invalid", 0 },
+  { "k_EContentCheckProvider_Local", 3 },
+};
+const ProtobufCEnumDescriptor econtent_check_provider__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EContentCheckProvider",
+  "EContentCheckProvider",
+  "EContentCheckProvider",
+  "",
+  4,
+  econtent_check_provider__enum_values_by_number,
+  4,
+  econtent_check_provider__enum_values_by_name,
+  1,
+  econtent_check_provider__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eprofile_customization_type__enum_values_by_number[25] =
+{
+  { "k_EProfileCustomizationTypeInvalid", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeInvalid", 0 },
+  { "k_EProfileCustomizationTypeRareAchievementShowcase", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeRareAchievementShowcase", 1 },
+  { "k_EProfileCustomizationTypeGameCollector", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeGameCollector", 2 },
+  { "k_EProfileCustomizationTypeItemShowcase", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeItemShowcase", 3 },
+  { "k_EProfileCustomizationTypeTradeShowcase", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeTradeShowcase", 4 },
+  { "k_EProfileCustomizationTypeBadges", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeBadges", 5 },
+  { "k_EProfileCustomizationTypeFavoriteGame", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeFavoriteGame", 6 },
+  { "k_EProfileCustomizationTypeScreenshotShowcase", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeScreenshotShowcase", 7 },
+  { "k_EProfileCustomizationTypeCustomText", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeCustomText", 8 },
+  { "k_EProfileCustomizationTypeFavoriteGroup", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeFavoriteGroup", 9 },
+  { "k_EProfileCustomizationTypeRecommendation", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeRecommendation", 10 },
+  { "k_EProfileCustomizationTypeWorkshopItem", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeWorkshopItem", 11 },
+  { "k_EProfileCustomizationTypeMyWorkshop", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeMyWorkshop", 12 },
+  { "k_EProfileCustomizationTypeArtworkShowcase", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeArtworkShowcase", 13 },
+  { "k_EProfileCustomizationTypeVideoShowcase", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeVideoShowcase", 14 },
+  { "k_EProfileCustomizationTypeGuides", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeGuides", 15 },
+  { "k_EProfileCustomizationTypeMyGuides", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeMyGuides", 16 },
+  { "k_EProfileCustomizationTypeAchievements", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeAchievements", 17 },
+  { "k_EProfileCustomizationTypeGreenlight", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeGreenlight", 18 },
+  { "k_EProfileCustomizationTypeMyGreenlight", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeMyGreenlight", 19 },
+  { "k_EProfileCustomizationTypeSalien", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeSalien", 20 },
+  { "k_EProfileCustomizationTypeLoyaltyRewardReactions", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeLoyaltyRewardReactions", 21 },
+  { "k_EProfileCustomizationTypeSingleArtworkShowcase", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeSingleArtworkShowcase", 22 },
+  { "k_EProfileCustomizationTypeAchievementsCompletionist", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeAchievementsCompletionist", 23 },
+  { "k_EProfileCustomizationTypeReplay", "EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeReplay", 24 },
+};
+static const ProtobufCIntRange eprofile_customization_type__value_ranges[] = {
+{0, 0},{0, 25}
+};
+static const ProtobufCEnumValueIndex eprofile_customization_type__enum_values_by_name[25] =
+{
+  { "k_EProfileCustomizationTypeAchievements", 17 },
+  { "k_EProfileCustomizationTypeAchievementsCompletionist", 23 },
+  { "k_EProfileCustomizationTypeArtworkShowcase", 13 },
+  { "k_EProfileCustomizationTypeBadges", 5 },
+  { "k_EProfileCustomizationTypeCustomText", 8 },
+  { "k_EProfileCustomizationTypeFavoriteGame", 6 },
+  { "k_EProfileCustomizationTypeFavoriteGroup", 9 },
+  { "k_EProfileCustomizationTypeGameCollector", 2 },
+  { "k_EProfileCustomizationTypeGreenlight", 18 },
+  { "k_EProfileCustomizationTypeGuides", 15 },
+  { "k_EProfileCustomizationTypeInvalid", 0 },
+  { "k_EProfileCustomizationTypeItemShowcase", 3 },
+  { "k_EProfileCustomizationTypeLoyaltyRewardReactions", 21 },
+  { "k_EProfileCustomizationTypeMyGreenlight", 19 },
+  { "k_EProfileCustomizationTypeMyGuides", 16 },
+  { "k_EProfileCustomizationTypeMyWorkshop", 12 },
+  { "k_EProfileCustomizationTypeRareAchievementShowcase", 1 },
+  { "k_EProfileCustomizationTypeRecommendation", 10 },
+  { "k_EProfileCustomizationTypeReplay", 24 },
+  { "k_EProfileCustomizationTypeSalien", 20 },
+  { "k_EProfileCustomizationTypeScreenshotShowcase", 7 },
+  { "k_EProfileCustomizationTypeSingleArtworkShowcase", 22 },
+  { "k_EProfileCustomizationTypeTradeShowcase", 4 },
+  { "k_EProfileCustomizationTypeVideoShowcase", 14 },
+  { "k_EProfileCustomizationTypeWorkshopItem", 11 },
+};
+const ProtobufCEnumDescriptor eprofile_customization_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EProfileCustomizationType",
+  "EProfileCustomizationType",
+  "EProfileCustomizationType",
+  "",
+  25,
+  eprofile_customization_type__enum_values_by_number,
+  25,
+  eprofile_customization_type__enum_values_by_name,
+  1,
+  eprofile_customization_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue epublished_file_storage_system__enum_values_by_number[4] =
+{
+  { "k_EPublishedFileStorageSystemInvalid", "EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemInvalid", 0 },
+  { "k_EPublishedFileStorageSystemLegacyCloud", "EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemLegacyCloud", 1 },
+  { "k_EPublishedFileStorageSystemDepot", "EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemDepot", 2 },
+  { "k_EPublishedFileStorageSystemUGCCloud", "EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemUGCCloud", 3 },
+};
+static const ProtobufCIntRange epublished_file_storage_system__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex epublished_file_storage_system__enum_values_by_name[4] =
+{
+  { "k_EPublishedFileStorageSystemDepot", 2 },
+  { "k_EPublishedFileStorageSystemInvalid", 0 },
+  { "k_EPublishedFileStorageSystemLegacyCloud", 1 },
+  { "k_EPublishedFileStorageSystemUGCCloud", 3 },
+};
+const ProtobufCEnumDescriptor epublished_file_storage_system__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EPublishedFileStorageSystem",
+  "EPublishedFileStorageSystem",
+  "EPublishedFileStorageSystem",
+  "",
+  4,
+  epublished_file_storage_system__enum_values_by_number,
+  4,
+  epublished_file_storage_system__enum_values_by_name,
+  1,
+  epublished_file_storage_system__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue ecloud_storage_persist_state__enum_values_by_number[3] =
+{
+  { "k_ECloudStoragePersistStatePersisted", "ECLOUD_STORAGE_PERSIST_STATE__k_ECloudStoragePersistStatePersisted", 0 },
+  { "k_ECloudStoragePersistStateForgotten", "ECLOUD_STORAGE_PERSIST_STATE__k_ECloudStoragePersistStateForgotten", 1 },
+  { "k_ECloudStoragePersistStateDeleted", "ECLOUD_STORAGE_PERSIST_STATE__k_ECloudStoragePersistStateDeleted", 2 },
+};
+static const ProtobufCIntRange ecloud_storage_persist_state__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex ecloud_storage_persist_state__enum_values_by_name[3] =
+{
+  { "k_ECloudStoragePersistStateDeleted", 2 },
+  { "k_ECloudStoragePersistStateForgotten", 1 },
+  { "k_ECloudStoragePersistStatePersisted", 0 },
+};
+const ProtobufCEnumDescriptor ecloud_storage_persist_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ECloudStoragePersistState",
+  "ECloudStoragePersistState",
+  "ECloudStoragePersistState",
+  "",
+  3,
+  ecloud_storage_persist_state__enum_values_by_number,
+  3,
+  ecloud_storage_persist_state__enum_values_by_name,
+  1,
+  ecloud_storage_persist_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esdcard_format_stage__enum_values_by_number[6] =
+{
+  { "k_ESDCardFormatStage_Invalid", "ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Invalid", 0 },
+  { "k_ESDCardFormatStage_Starting", "ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Starting", 1 },
+  { "k_ESDCardFormatStage_Testing", "ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Testing", 2 },
+  { "k_ESDCardFormatStage_Rescuing", "ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Rescuing", 3 },
+  { "k_ESDCardFormatStage_Formatting", "ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Formatting", 4 },
+  { "k_ESDCardFormatStage_Finalizing", "ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Finalizing", 5 },
+};
+static const ProtobufCIntRange esdcard_format_stage__value_ranges[] = {
+{0, 0},{0, 6}
+};
+static const ProtobufCEnumValueIndex esdcard_format_stage__enum_values_by_name[6] =
+{
+  { "k_ESDCardFormatStage_Finalizing", 5 },
+  { "k_ESDCardFormatStage_Formatting", 4 },
+  { "k_ESDCardFormatStage_Invalid", 0 },
+  { "k_ESDCardFormatStage_Rescuing", 3 },
+  { "k_ESDCardFormatStage_Starting", 1 },
+  { "k_ESDCardFormatStage_Testing", 2 },
+};
+const ProtobufCEnumDescriptor esdcard_format_stage__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESDCardFormatStage",
+  "ESDCardFormatStage",
+  "ESDCardFormatStage",
+  "",
+  6,
+  esdcard_format_stage__enum_values_by_number,
+  6,
+  esdcard_format_stage__enum_values_by_name,
+  1,
+  esdcard_format_stage__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esystem_fan_control_mode__enum_values_by_number[3] =
+{
+  { "k_SystemFanControlMode_Invalid", "ESYSTEM_FAN_CONTROL_MODE__k_SystemFanControlMode_Invalid", 0 },
+  { "k_SystemFanControlMode_Disabled", "ESYSTEM_FAN_CONTROL_MODE__k_SystemFanControlMode_Disabled", 1 },
+  { "k_SystemFanControlMode_Default", "ESYSTEM_FAN_CONTROL_MODE__k_SystemFanControlMode_Default", 2 },
+};
+static const ProtobufCIntRange esystem_fan_control_mode__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex esystem_fan_control_mode__enum_values_by_name[3] =
+{
+  { "k_SystemFanControlMode_Default", 2 },
+  { "k_SystemFanControlMode_Disabled", 1 },
+  { "k_SystemFanControlMode_Invalid", 0 },
+};
+const ProtobufCEnumDescriptor esystem_fan_control_mode__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESystemFanControlMode",
+  "ESystemFanControlMode",
+  "ESystemFanControlMode",
+  "",
+  3,
+  esystem_fan_control_mode__enum_values_by_number,
+  3,
+  esystem_fan_control_mode__enum_values_by_name,
+  1,
+  esystem_fan_control_mode__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue ecolor_profile__enum_values_by_number[4] =
+{
+  { "k_EColorProfile_Invalid", "ECOLOR_PROFILE__k_EColorProfile_Invalid", 0 },
+  { "k_EColorProfile_Native", "ECOLOR_PROFILE__k_EColorProfile_Native", 1 },
+  { "k_EColorProfile_Standard", "ECOLOR_PROFILE__k_EColorProfile_Standard", 2 },
+  { "k_EColorProfile_Vivid", "ECOLOR_PROFILE__k_EColorProfile_Vivid", 3 },
+};
+static const ProtobufCIntRange ecolor_profile__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex ecolor_profile__enum_values_by_name[4] =
+{
+  { "k_EColorProfile_Invalid", 0 },
+  { "k_EColorProfile_Native", 1 },
+  { "k_EColorProfile_Standard", 2 },
+  { "k_EColorProfile_Vivid", 3 },
+};
+const ProtobufCEnumDescriptor ecolor_profile__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EColorProfile",
+  "EColorProfile",
+  "EColorProfile",
+  "",
+  4,
+  ecolor_profile__enum_values_by_number,
+  4,
+  ecolor_profile__enum_values_by_name,
+  1,
+  ecolor_profile__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue ebluetooth_device_type__enum_values_by_number[12] =
+{
+  { "k_BluetoothDeviceType_Invalid", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Invalid", 0 },
+  { "k_BluetoothDeviceType_Unknown", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Unknown", 1 },
+  { "k_BluetoothDeviceType_Phone", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Phone", 2 },
+  { "k_BluetoothDeviceType_Computer", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Computer", 3 },
+  { "k_BluetoothDeviceType_Headset", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Headset", 4 },
+  { "k_BluetoothDeviceType_Headphones", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Headphones", 5 },
+  { "k_BluetoothDeviceType_Speakers", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Speakers", 6 },
+  { "k_BluetoothDeviceType_OtherAudio", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_OtherAudio", 7 },
+  { "k_BluetoothDeviceType_Mouse", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Mouse", 8 },
+  { "k_BluetoothDeviceType_Joystick", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Joystick", 9 },
+  { "k_BluetoothDeviceType_Gamepad", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Gamepad", 10 },
+  { "k_BluetoothDeviceType_Keyboard", "EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Keyboard", 11 },
+};
+static const ProtobufCIntRange ebluetooth_device_type__value_ranges[] = {
+{0, 0},{0, 12}
+};
+static const ProtobufCEnumValueIndex ebluetooth_device_type__enum_values_by_name[12] =
+{
+  { "k_BluetoothDeviceType_Computer", 3 },
+  { "k_BluetoothDeviceType_Gamepad", 10 },
+  { "k_BluetoothDeviceType_Headphones", 5 },
+  { "k_BluetoothDeviceType_Headset", 4 },
+  { "k_BluetoothDeviceType_Invalid", 0 },
+  { "k_BluetoothDeviceType_Joystick", 9 },
+  { "k_BluetoothDeviceType_Keyboard", 11 },
+  { "k_BluetoothDeviceType_Mouse", 8 },
+  { "k_BluetoothDeviceType_OtherAudio", 7 },
+  { "k_BluetoothDeviceType_Phone", 2 },
+  { "k_BluetoothDeviceType_Speakers", 6 },
+  { "k_BluetoothDeviceType_Unknown", 1 },
+};
+const ProtobufCEnumDescriptor ebluetooth_device_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EBluetoothDeviceType",
+  "EBluetoothDeviceType",
+  "EBluetoothDeviceType",
+  "",
+  12,
+  ebluetooth_device_type__enum_values_by_number,
+  12,
+  ebluetooth_device_type__enum_values_by_name,
+  1,
+  ebluetooth_device_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esystem_audio_direction__enum_values_by_number[3] =
+{
+  { "k_SystemAudioDirection_Invalid", "ESYSTEM_AUDIO_DIRECTION__k_SystemAudioDirection_Invalid", 0 },
+  { "k_SystemAudioDirection_Input", "ESYSTEM_AUDIO_DIRECTION__k_SystemAudioDirection_Input", 1 },
+  { "k_SystemAudioDirection_Output", "ESYSTEM_AUDIO_DIRECTION__k_SystemAudioDirection_Output", 2 },
+};
+static const ProtobufCIntRange esystem_audio_direction__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex esystem_audio_direction__enum_values_by_name[3] =
+{
+  { "k_SystemAudioDirection_Input", 1 },
+  { "k_SystemAudioDirection_Invalid", 0 },
+  { "k_SystemAudioDirection_Output", 2 },
+};
+const ProtobufCEnumDescriptor esystem_audio_direction__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESystemAudioDirection",
+  "ESystemAudioDirection",
+  "ESystemAudioDirection",
+  "",
+  3,
+  esystem_audio_direction__enum_values_by_number,
+  3,
+  esystem_audio_direction__enum_values_by_name,
+  1,
+  esystem_audio_direction__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esystem_audio_channel__enum_values_by_number[10] =
+{
+  { "k_SystemAudioChannel_Invalid", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Invalid", 0 },
+  { "k_SystemAudioChannel_Aggregated", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Aggregated", 1 },
+  { "k_SystemAudioChannel_FrontLeft", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_FrontLeft", 2 },
+  { "k_SystemAudioChannel_FrontRight", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_FrontRight", 3 },
+  { "k_SystemAudioChannel_LFE", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_LFE", 4 },
+  { "k_SystemAudioChannel_BackLeft", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_BackLeft", 5 },
+  { "k_SystemAudioChannel_BackRight", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_BackRight", 6 },
+  { "k_SystemAudioChannel_FrontCenter", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_FrontCenter", 7 },
+  { "k_SystemAudioChannel_Unknown", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Unknown", 8 },
+  { "k_SystemAudioChannel_Mono", "ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Mono", 9 },
+};
+static const ProtobufCIntRange esystem_audio_channel__value_ranges[] = {
+{0, 0},{0, 10}
+};
+static const ProtobufCEnumValueIndex esystem_audio_channel__enum_values_by_name[10] =
+{
+  { "k_SystemAudioChannel_Aggregated", 1 },
+  { "k_SystemAudioChannel_BackLeft", 5 },
+  { "k_SystemAudioChannel_BackRight", 6 },
+  { "k_SystemAudioChannel_FrontCenter", 7 },
+  { "k_SystemAudioChannel_FrontLeft", 2 },
+  { "k_SystemAudioChannel_FrontRight", 3 },
+  { "k_SystemAudioChannel_Invalid", 0 },
+  { "k_SystemAudioChannel_LFE", 4 },
+  { "k_SystemAudioChannel_Mono", 9 },
+  { "k_SystemAudioChannel_Unknown", 8 },
+};
+const ProtobufCEnumDescriptor esystem_audio_channel__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESystemAudioChannel",
+  "ESystemAudioChannel",
+  "ESystemAudioChannel",
+  "",
+  10,
+  esystem_audio_channel__enum_values_by_number,
+  10,
+  esystem_audio_channel__enum_values_by_name,
+  1,
+  esystem_audio_channel__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esystem_audio_port_type__enum_values_by_number[5] =
+{
+  { "k_SystemAudioPortType_Invalid", "ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Invalid", 0 },
+  { "k_SystemAudioPortType_Unknown", "ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Unknown", 1 },
+  { "k_SystemAudioPortType_Audio32f", "ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Audio32f", 2 },
+  { "k_SystemAudioPortType_Midi8b", "ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Midi8b", 3 },
+  { "k_SystemAudioPortType_Video32RGBA", "ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Video32RGBA", 4 },
+};
+static const ProtobufCIntRange esystem_audio_port_type__value_ranges[] = {
+{0, 0},{0, 5}
+};
+static const ProtobufCEnumValueIndex esystem_audio_port_type__enum_values_by_name[5] =
+{
+  { "k_SystemAudioPortType_Audio32f", 2 },
+  { "k_SystemAudioPortType_Invalid", 0 },
+  { "k_SystemAudioPortType_Midi8b", 3 },
+  { "k_SystemAudioPortType_Unknown", 1 },
+  { "k_SystemAudioPortType_Video32RGBA", 4 },
+};
+const ProtobufCEnumDescriptor esystem_audio_port_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESystemAudioPortType",
+  "ESystemAudioPortType",
+  "ESystemAudioPortType",
+  "",
+  5,
+  esystem_audio_port_type__enum_values_by_number,
+  5,
+  esystem_audio_port_type__enum_values_by_name,
+  1,
+  esystem_audio_port_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esystem_audio_port_direction__enum_values_by_number[3] =
+{
+  { "k_SystemAudioPortDirection_Invalid", "ESYSTEM_AUDIO_PORT_DIRECTION__k_SystemAudioPortDirection_Invalid", 0 },
+  { "k_SystemAudioPortDirection_Input", "ESYSTEM_AUDIO_PORT_DIRECTION__k_SystemAudioPortDirection_Input", 1 },
+  { "k_SystemAudioPortDirection_Output", "ESYSTEM_AUDIO_PORT_DIRECTION__k_SystemAudioPortDirection_Output", 2 },
+};
+static const ProtobufCIntRange esystem_audio_port_direction__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex esystem_audio_port_direction__enum_values_by_name[3] =
+{
+  { "k_SystemAudioPortDirection_Input", 1 },
+  { "k_SystemAudioPortDirection_Invalid", 0 },
+  { "k_SystemAudioPortDirection_Output", 2 },
+};
+const ProtobufCEnumDescriptor esystem_audio_port_direction__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESystemAudioPortDirection",
+  "ESystemAudioPortDirection",
+  "ESystemAudioPortDirection",
+  "",
+  3,
+  esystem_audio_port_direction__enum_values_by_number,
+  3,
+  esystem_audio_port_direction__enum_values_by_name,
+  1,
+  esystem_audio_port_direction__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esystem_service_state__enum_values_by_number[3] =
+{
+  { "k_ESystemServiceState_Unavailable", "ESYSTEM_SERVICE_STATE__k_ESystemServiceState_Unavailable", 0 },
+  { "k_ESystemServiceState_Disabled", "ESYSTEM_SERVICE_STATE__k_ESystemServiceState_Disabled", 1 },
+  { "k_ESystemServiceState_Enabled", "ESYSTEM_SERVICE_STATE__k_ESystemServiceState_Enabled", 2 },
+};
+static const ProtobufCIntRange esystem_service_state__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex esystem_service_state__enum_values_by_name[3] =
+{
+  { "k_ESystemServiceState_Disabled", 1 },
+  { "k_ESystemServiceState_Enabled", 2 },
+  { "k_ESystemServiceState_Unavailable", 0 },
+};
+const ProtobufCEnumDescriptor esystem_service_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESystemServiceState",
+  "ESystemServiceState",
+  "ESystemServiceState",
+  "",
+  3,
+  esystem_service_state__enum_values_by_number,
+  3,
+  esystem_service_state__enum_values_by_name,
+  1,
+  esystem_service_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue egraphics_perf_overlay_level__enum_values_by_number[5] =
+{
+  { "k_EGraphicsPerfOverlayLevel_Hidden", "EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Hidden", 0 },
+  { "k_EGraphicsPerfOverlayLevel_Basic", "EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Basic", 1 },
+  { "k_EGraphicsPerfOverlayLevel_Medium", "EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Medium", 2 },
+  { "k_EGraphicsPerfOverlayLevel_Full", "EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Full", 3 },
+  { "k_EGraphicsPerfOverlayLevel_Minimal", "EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Minimal", 4 },
+};
+static const ProtobufCIntRange egraphics_perf_overlay_level__value_ranges[] = {
+{0, 0},{0, 5}
+};
+static const ProtobufCEnumValueIndex egraphics_perf_overlay_level__enum_values_by_name[5] =
+{
+  { "k_EGraphicsPerfOverlayLevel_Basic", 1 },
+  { "k_EGraphicsPerfOverlayLevel_Full", 3 },
+  { "k_EGraphicsPerfOverlayLevel_Hidden", 0 },
+  { "k_EGraphicsPerfOverlayLevel_Medium", 2 },
+  { "k_EGraphicsPerfOverlayLevel_Minimal", 4 },
+};
+const ProtobufCEnumDescriptor egraphics_perf_overlay_level__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EGraphicsPerfOverlayLevel",
+  "EGraphicsPerfOverlayLevel",
+  "EGraphicsPerfOverlayLevel",
+  "",
+  5,
+  egraphics_perf_overlay_level__enum_values_by_number,
+  5,
+  egraphics_perf_overlay_level__enum_values_by_name,
+  1,
+  egraphics_perf_overlay_level__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue egpuperformance_level__enum_values_by_number[6] =
+{
+  { "k_EGPUPerformanceLevel_Invalid", "EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Invalid", 0 },
+  { "k_EGPUPerformanceLevel_Auto", "EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Auto", 1 },
+  { "k_EGPUPerformanceLevel_Manual", "EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Manual", 2 },
+  { "k_EGPUPerformanceLevel_Low", "EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Low", 3 },
+  { "k_EGPUPerformanceLevel_High", "EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_High", 4 },
+  { "k_EGPUPerformanceLevel_Profiling", "EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Profiling", 5 },
+};
+static const ProtobufCIntRange egpuperformance_level__value_ranges[] = {
+{0, 0},{0, 6}
+};
+static const ProtobufCEnumValueIndex egpuperformance_level__enum_values_by_name[6] =
+{
+  { "k_EGPUPerformanceLevel_Auto", 1 },
+  { "k_EGPUPerformanceLevel_High", 4 },
+  { "k_EGPUPerformanceLevel_Invalid", 0 },
+  { "k_EGPUPerformanceLevel_Low", 3 },
+  { "k_EGPUPerformanceLevel_Manual", 2 },
+  { "k_EGPUPerformanceLevel_Profiling", 5 },
+};
+const ProtobufCEnumDescriptor egpuperformance_level__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EGPUPerformanceLevel",
+  "EGPUPerformanceLevel",
+  "EGPUPerformanceLevel",
+  "",
+  6,
+  egpuperformance_level__enum_values_by_number,
+  6,
+  egpuperformance_level__enum_values_by_name,
+  1,
+  egpuperformance_level__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue escaling_filter__enum_values_by_number[6] =
+{
+  { "k_EScalingFilter_Invalid", "ESCALING_FILTER__k_EScalingFilter_Invalid", 0 },
+  { "k_EScalingFilter_FSR", "ESCALING_FILTER__k_EScalingFilter_FSR", 1 },
+  { "k_EScalingFilter_Nearest", "ESCALING_FILTER__k_EScalingFilter_Nearest", 2 },
+  { "k_EScalingFilter_Integer", "ESCALING_FILTER__k_EScalingFilter_Integer", 3 },
+  { "k_EScalingFilter_Linear", "ESCALING_FILTER__k_EScalingFilter_Linear", 4 },
+  { "k_EScalingFilter_NIS", "ESCALING_FILTER__k_EScalingFilter_NIS", 5 },
+};
+static const ProtobufCIntRange escaling_filter__value_ranges[] = {
+{0, 0},{0, 6}
+};
+static const ProtobufCEnumValueIndex escaling_filter__enum_values_by_name[6] =
+{
+  { "k_EScalingFilter_FSR", 1 },
+  { "k_EScalingFilter_Integer", 3 },
+  { "k_EScalingFilter_Invalid", 0 },
+  { "k_EScalingFilter_Linear", 4 },
+  { "k_EScalingFilter_NIS", 5 },
+  { "k_EScalingFilter_Nearest", 2 },
+};
+const ProtobufCEnumDescriptor escaling_filter__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EScalingFilter",
+  "EScalingFilter",
+  "EScalingFilter",
+  "",
+  6,
+  escaling_filter__enum_values_by_number,
+  6,
+  escaling_filter__enum_values_by_name,
+  1,
+  escaling_filter__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esplit_scaling_filter__enum_values_by_number[5] =
+{
+  { "k_ESplitScalingFilter_Invalid", "ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_Invalid", 0 },
+  { "k_ESplitScalingFilter_Linear", "ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_Linear", 1 },
+  { "k_ESplitScalingFilter_Nearest", "ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_Nearest", 2 },
+  { "k_ESplitScalingFilter_FSR", "ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_FSR", 3 },
+  { "k_ESplitScalingFilter_NIS", "ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_NIS", 4 },
+};
+static const ProtobufCIntRange esplit_scaling_filter__value_ranges[] = {
+{0, 0},{0, 5}
+};
+static const ProtobufCEnumValueIndex esplit_scaling_filter__enum_values_by_name[5] =
+{
+  { "k_ESplitScalingFilter_FSR", 3 },
+  { "k_ESplitScalingFilter_Invalid", 0 },
+  { "k_ESplitScalingFilter_Linear", 1 },
+  { "k_ESplitScalingFilter_NIS", 4 },
+  { "k_ESplitScalingFilter_Nearest", 2 },
+};
+const ProtobufCEnumDescriptor esplit_scaling_filter__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESplitScalingFilter",
+  "ESplitScalingFilter",
+  "ESplitScalingFilter",
+  "",
+  5,
+  esplit_scaling_filter__enum_values_by_number,
+  5,
+  esplit_scaling_filter__enum_values_by_name,
+  1,
+  esplit_scaling_filter__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esplit_scaling_scaler__enum_values_by_number[6] =
+{
+  { "k_ESplitScalingScaler_Invalid", "ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Invalid", 0 },
+  { "k_ESplitScalingScaler_Auto", "ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Auto", 1 },
+  { "k_ESplitScalingScaler_Integer", "ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Integer", 2 },
+  { "k_ESplitScalingScaler_Fit", "ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Fit", 3 },
+  { "k_ESplitScalingScaler_Fill", "ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Fill", 4 },
+  { "k_ESplitScalingScaler_Stretch", "ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Stretch", 5 },
+};
+static const ProtobufCIntRange esplit_scaling_scaler__value_ranges[] = {
+{0, 0},{0, 6}
+};
+static const ProtobufCEnumValueIndex esplit_scaling_scaler__enum_values_by_name[6] =
+{
+  { "k_ESplitScalingScaler_Auto", 1 },
+  { "k_ESplitScalingScaler_Fill", 4 },
+  { "k_ESplitScalingScaler_Fit", 3 },
+  { "k_ESplitScalingScaler_Integer", 2 },
+  { "k_ESplitScalingScaler_Invalid", 0 },
+  { "k_ESplitScalingScaler_Stretch", 5 },
+};
+const ProtobufCEnumDescriptor esplit_scaling_scaler__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESplitScalingScaler",
+  "ESplitScalingScaler",
+  "ESplitScalingScaler",
+  "",
+  6,
+  esplit_scaling_scaler__enum_values_by_number,
+  6,
+  esplit_scaling_scaler__enum_values_by_name,
+  1,
+  esplit_scaling_scaler__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue ehdrtone_map_operator__enum_values_by_number[3] =
+{
+  { "k_EHDRToneMapOperator_Invalid", "EHDRTONE_MAP_OPERATOR__k_EHDRToneMapOperator_Invalid", 0 },
+  { "k_EHDRToneMapOperator_Uncharted", "EHDRTONE_MAP_OPERATOR__k_EHDRToneMapOperator_Uncharted", 1 },
+  { "k_EHDRToneMapOperator_Reinhard", "EHDRTONE_MAP_OPERATOR__k_EHDRToneMapOperator_Reinhard", 2 },
+};
+static const ProtobufCIntRange ehdrtone_map_operator__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex ehdrtone_map_operator__enum_values_by_name[3] =
+{
+  { "k_EHDRToneMapOperator_Invalid", 0 },
+  { "k_EHDRToneMapOperator_Reinhard", 2 },
+  { "k_EHDRToneMapOperator_Uncharted", 1 },
+};
+const ProtobufCEnumDescriptor ehdrtone_map_operator__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EHDRToneMapOperator",
+  "EHDRToneMapOperator",
+  "EHDRToneMapOperator",
+  "",
+  3,
+  ehdrtone_map_operator__enum_values_by_number,
+  3,
+  ehdrtone_map_operator__enum_values_by_name,
+  1,
+  ehdrtone_map_operator__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue ecpugovernor__enum_values_by_number[4] =
+{
+  { "k_ECPUGovernor_Invalid", "ECPUGOVERNOR__k_ECPUGovernor_Invalid", 0 },
+  { "k_ECPUGovernor_Perf", "ECPUGOVERNOR__k_ECPUGovernor_Perf", 1 },
+  { "k_ECPUGovernor_Powersave", "ECPUGOVERNOR__k_ECPUGovernor_Powersave", 2 },
+  { "k_ECPUGovernor_Manual", "ECPUGOVERNOR__k_ECPUGovernor_Manual", 3 },
+};
+static const ProtobufCIntRange ecpugovernor__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex ecpugovernor__enum_values_by_name[4] =
+{
+  { "k_ECPUGovernor_Invalid", 0 },
+  { "k_ECPUGovernor_Manual", 3 },
+  { "k_ECPUGovernor_Perf", 1 },
+  { "k_ECPUGovernor_Powersave", 2 },
+};
+const ProtobufCEnumDescriptor ecpugovernor__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ECPUGovernor",
+  "ECPUGovernor",
+  "ECPUGovernor",
+  "",
+  4,
+  ecpugovernor__enum_values_by_number,
+  4,
+  ecpugovernor__enum_values_by_name,
+  1,
+  ecpugovernor__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eupdater_type__enum_values_by_number[8] =
+{
+  { "k_EUpdaterType_Invalid", "EUPDATER_TYPE__k_EUpdaterType_Invalid", 0 },
+  { "k_EUpdaterType_Client", "EUPDATER_TYPE__k_EUpdaterType_Client", 1 },
+  { "k_EUpdaterType_OS", "EUPDATER_TYPE__k_EUpdaterType_OS", 2 },
+  { "k_EUpdaterType_BIOS", "EUPDATER_TYPE__k_EUpdaterType_BIOS", 3 },
+  { "k_EUpdaterType_Aggregated", "EUPDATER_TYPE__k_EUpdaterType_Aggregated", 4 },
+  { "k_EUpdaterType_Test1", "EUPDATER_TYPE__k_EUpdaterType_Test1", 5 },
+  { "k_EUpdaterType_Test2", "EUPDATER_TYPE__k_EUpdaterType_Test2", 6 },
+  { "k_EUpdaterType_Dummy", "EUPDATER_TYPE__k_EUpdaterType_Dummy", 7 },
+};
+static const ProtobufCIntRange eupdater_type__value_ranges[] = {
+{0, 0},{0, 8}
+};
+static const ProtobufCEnumValueIndex eupdater_type__enum_values_by_name[8] =
+{
+  { "k_EUpdaterType_Aggregated", 4 },
+  { "k_EUpdaterType_BIOS", 3 },
+  { "k_EUpdaterType_Client", 1 },
+  { "k_EUpdaterType_Dummy", 7 },
+  { "k_EUpdaterType_Invalid", 0 },
+  { "k_EUpdaterType_OS", 2 },
+  { "k_EUpdaterType_Test1", 5 },
+  { "k_EUpdaterType_Test2", 6 },
+};
+const ProtobufCEnumDescriptor eupdater_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EUpdaterType",
+  "EUpdaterType",
+  "EUpdaterType",
+  "",
+  8,
+  eupdater_type__enum_values_by_number,
+  8,
+  eupdater_type__enum_values_by_name,
+  1,
+  eupdater_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eupdater_state__enum_values_by_number[7] =
+{
+  { "k_EUpdaterState_Invalid", "EUPDATER_STATE__k_EUpdaterState_Invalid", 0 },
+  { "k_EUpdaterState_UpToDate", "EUPDATER_STATE__k_EUpdaterState_UpToDate", 2 },
+  { "k_EUpdaterState_Checking", "EUPDATER_STATE__k_EUpdaterState_Checking", 3 },
+  { "k_EUpdaterState_Available", "EUPDATER_STATE__k_EUpdaterState_Available", 4 },
+  { "k_EUpdaterState_Applying", "EUPDATER_STATE__k_EUpdaterState_Applying", 5 },
+  { "k_EUpdaterState_ClientRestartPending", "EUPDATER_STATE__k_EUpdaterState_ClientRestartPending", 6 },
+  { "k_EUpdaterState_SystemRestartPending", "EUPDATER_STATE__k_EUpdaterState_SystemRestartPending", 7 },
+};
+static const ProtobufCIntRange eupdater_state__value_ranges[] = {
+{0, 0},{2, 1},{0, 7}
+};
+static const ProtobufCEnumValueIndex eupdater_state__enum_values_by_name[7] =
+{
+  { "k_EUpdaterState_Applying", 4 },
+  { "k_EUpdaterState_Available", 3 },
+  { "k_EUpdaterState_Checking", 2 },
+  { "k_EUpdaterState_ClientRestartPending", 5 },
+  { "k_EUpdaterState_Invalid", 0 },
+  { "k_EUpdaterState_SystemRestartPending", 6 },
+  { "k_EUpdaterState_UpToDate", 1 },
+};
+const ProtobufCEnumDescriptor eupdater_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EUpdaterState",
+  "EUpdaterState",
+  "EUpdaterState",
+  "",
+  7,
+  eupdater_state__enum_values_by_number,
+  7,
+  eupdater_state__enum_values_by_name,
+  2,
+  eupdater_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue estorage_block_content_type__enum_values_by_number[5] =
+{
+  { "k_EStorageBlockContentType_Invalid", "ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Invalid", 0 },
+  { "k_EStorageBlockContentType_Unknown", "ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Unknown", 1 },
+  { "k_EStorageBlockContentType_FileSystem", "ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_FileSystem", 2 },
+  { "k_EStorageBlockContentType_Crypto", "ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Crypto", 3 },
+  { "k_EStorageBlockContentType_Raid", "ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Raid", 4 },
+};
+static const ProtobufCIntRange estorage_block_content_type__value_ranges[] = {
+{0, 0},{0, 5}
+};
+static const ProtobufCEnumValueIndex estorage_block_content_type__enum_values_by_name[5] =
+{
+  { "k_EStorageBlockContentType_Crypto", 3 },
+  { "k_EStorageBlockContentType_FileSystem", 2 },
+  { "k_EStorageBlockContentType_Invalid", 0 },
+  { "k_EStorageBlockContentType_Raid", 4 },
+  { "k_EStorageBlockContentType_Unknown", 1 },
+};
+const ProtobufCEnumDescriptor estorage_block_content_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EStorageBlockContentType",
+  "EStorageBlockContentType",
+  "EStorageBlockContentType",
+  "",
+  5,
+  estorage_block_content_type__enum_values_by_number,
+  5,
+  estorage_block_content_type__enum_values_by_name,
+  1,
+  estorage_block_content_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue estorage_block_file_system_type__enum_values_by_number[4] =
+{
+  { "k_EStorageBlockFileSystemType_Invalid", "ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_Invalid", 0 },
+  { "k_EStorageBlockFileSystemType_Unknown", "ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_Unknown", 1 },
+  { "k_EStorageBlockFileSystemType_VFat", "ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_VFat", 2 },
+  { "k_EStorageBlockFileSystemType_Ext4", "ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_Ext4", 3 },
+};
+static const ProtobufCIntRange estorage_block_file_system_type__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex estorage_block_file_system_type__enum_values_by_name[4] =
+{
+  { "k_EStorageBlockFileSystemType_Ext4", 3 },
+  { "k_EStorageBlockFileSystemType_Invalid", 0 },
+  { "k_EStorageBlockFileSystemType_Unknown", 1 },
+  { "k_EStorageBlockFileSystemType_VFat", 2 },
+};
+const ProtobufCEnumDescriptor estorage_block_file_system_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EStorageBlockFileSystemType",
+  "EStorageBlockFileSystemType",
+  "EStorageBlockFileSystemType",
+  "",
+  4,
+  estorage_block_file_system_type__enum_values_by_number,
+  4,
+  estorage_block_file_system_type__enum_values_by_name,
+  1,
+  estorage_block_file_system_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue estorage_drive_media_type__enum_values_by_number[5] =
+{
+  { "k_EStorageDriveMediaType_Invalid", "ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_Invalid", 0 },
+  { "k_EStorageDriveMediaType_Unknown", "ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_Unknown", 1 },
+  { "k_EStorageDriveMediaType_HDD", "ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_HDD", 2 },
+  { "k_EStorageDriveMediaType_SSD", "ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_SSD", 3 },
+  { "k_EStorageDriveMediaType_Removable", "ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_Removable", 4 },
+};
+static const ProtobufCIntRange estorage_drive_media_type__value_ranges[] = {
+{0, 0},{0, 5}
+};
+static const ProtobufCEnumValueIndex estorage_drive_media_type__enum_values_by_name[5] =
+{
+  { "k_EStorageDriveMediaType_HDD", 2 },
+  { "k_EStorageDriveMediaType_Invalid", 0 },
+  { "k_EStorageDriveMediaType_Removable", 4 },
+  { "k_EStorageDriveMediaType_SSD", 3 },
+  { "k_EStorageDriveMediaType_Unknown", 1 },
+};
+const ProtobufCEnumDescriptor estorage_drive_media_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EStorageDriveMediaType",
+  "EStorageDriveMediaType",
+  "EStorageDriveMediaType",
+  "",
+  5,
+  estorage_drive_media_type__enum_values_by_number,
+  5,
+  estorage_drive_media_type__enum_values_by_name,
+  1,
+  estorage_drive_media_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esystem_display_compatibility_mode__enum_values_by_number[3] =
+{
+  { "k_ESystemDisplayCompatibilityMode_Invalid", "ESYSTEM_DISPLAY_COMPATIBILITY_MODE__k_ESystemDisplayCompatibilityMode_Invalid", 0 },
+  { "k_ESystemDisplayCompatibilityMode_None", "ESYSTEM_DISPLAY_COMPATIBILITY_MODE__k_ESystemDisplayCompatibilityMode_None", 1 },
+  { "k_ESystemDisplayCompatibilityMode_MinimalBandwith", "ESYSTEM_DISPLAY_COMPATIBILITY_MODE__k_ESystemDisplayCompatibilityMode_MinimalBandwith", 2 },
+};
+static const ProtobufCIntRange esystem_display_compatibility_mode__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex esystem_display_compatibility_mode__enum_values_by_name[3] =
+{
+  { "k_ESystemDisplayCompatibilityMode_Invalid", 0 },
+  { "k_ESystemDisplayCompatibilityMode_MinimalBandwith", 2 },
+  { "k_ESystemDisplayCompatibilityMode_None", 1 },
+};
+const ProtobufCEnumDescriptor esystem_display_compatibility_mode__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESystemDisplayCompatibilityMode",
+  "ESystemDisplayCompatibilityMode",
+  "ESystemDisplayCompatibilityMode",
+  "",
+  3,
+  esystem_display_compatibility_mode__enum_values_by_number,
+  3,
+  esystem_display_compatibility_mode__enum_values_by_name,
+  1,
+  esystem_display_compatibility_mode__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esteam_deck_compatibility_category__enum_values_by_number[4] =
+{
+  { "k_ESteamDeckCompatibilityCategory_Unknown", "ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Unknown", 0 },
+  { "k_ESteamDeckCompatibilityCategory_Unsupported", "ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Unsupported", 1 },
+  { "k_ESteamDeckCompatibilityCategory_Playable", "ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Playable", 2 },
+  { "k_ESteamDeckCompatibilityCategory_Verified", "ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Verified", 3 },
+};
+static const ProtobufCIntRange esteam_deck_compatibility_category__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex esteam_deck_compatibility_category__enum_values_by_name[4] =
+{
+  { "k_ESteamDeckCompatibilityCategory_Playable", 2 },
+  { "k_ESteamDeckCompatibilityCategory_Unknown", 0 },
+  { "k_ESteamDeckCompatibilityCategory_Unsupported", 1 },
+  { "k_ESteamDeckCompatibilityCategory_Verified", 3 },
+};
+const ProtobufCEnumDescriptor esteam_deck_compatibility_category__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESteamDeckCompatibilityCategory",
+  "ESteamDeckCompatibilityCategory",
+  "ESteamDeckCompatibilityCategory",
+  "",
+  4,
+  esteam_deck_compatibility_category__enum_values_by_number,
+  4,
+  esteam_deck_compatibility_category__enum_values_by_name,
+  1,
+  esteam_deck_compatibility_category__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esteam_deck_compatibility_result_display_type__enum_values_by_number[5] =
+{
+  { "k_ESteamDeckCompatibilityResultDisplayType_Invisible", "ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Invisible", 0 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Informational", "ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Informational", 1 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Unsupported", "ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Unsupported", 2 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Playable", "ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Playable", 3 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Verified", "ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Verified", 4 },
+};
+static const ProtobufCIntRange esteam_deck_compatibility_result_display_type__value_ranges[] = {
+{0, 0},{0, 5}
+};
+static const ProtobufCEnumValueIndex esteam_deck_compatibility_result_display_type__enum_values_by_name[5] =
+{
+  { "k_ESteamDeckCompatibilityResultDisplayType_Informational", 1 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Invisible", 0 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Playable", 3 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Unsupported", 2 },
+  { "k_ESteamDeckCompatibilityResultDisplayType_Verified", 4 },
+};
+const ProtobufCEnumDescriptor esteam_deck_compatibility_result_display_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESteamDeckCompatibilityResultDisplayType",
+  "ESteamDeckCompatibilityResultDisplayType",
+  "ESteamDeckCompatibilityResultDisplayType",
+  "",
+  5,
+  esteam_deck_compatibility_result_display_type__enum_values_by_number,
+  5,
+  esteam_deck_compatibility_result_display_type__enum_values_by_name,
+  1,
+  esteam_deck_compatibility_result_display_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eacstate__enum_values_by_number[4] =
+{
+  { "k_EACState_Unknown", "EACSTATE__k_EACState_Unknown", 0 },
+  { "k_EACState_Disconnected", "EACSTATE__k_EACState_Disconnected", 1 },
+  { "k_EACState_Connected", "EACSTATE__k_EACState_Connected", 2 },
+  { "k_EACState_ConnectedSlow", "EACSTATE__k_EACState_ConnectedSlow", 3 },
+};
+static const ProtobufCIntRange eacstate__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex eacstate__enum_values_by_name[4] =
+{
+  { "k_EACState_Connected", 2 },
+  { "k_EACState_ConnectedSlow", 3 },
+  { "k_EACState_Disconnected", 1 },
+  { "k_EACState_Unknown", 0 },
+};
+const ProtobufCEnumDescriptor eacstate__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EACState",
+  "EACState",
+  "EACState",
+  "",
+  4,
+  eacstate__enum_values_by_number,
+  4,
+  eacstate__enum_values_by_name,
+  1,
+  eacstate__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue ebattery_state__enum_values_by_number[4] =
+{
+  { "k_EBatteryState_Unknown", "EBATTERY_STATE__k_EBatteryState_Unknown", 0 },
+  { "k_EBatteryState_Discharging", "EBATTERY_STATE__k_EBatteryState_Discharging", 1 },
+  { "k_EBatteryState_Charging", "EBATTERY_STATE__k_EBatteryState_Charging", 2 },
+  { "k_EBatteryState_Full", "EBATTERY_STATE__k_EBatteryState_Full", 3 },
+};
+static const ProtobufCIntRange ebattery_state__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex ebattery_state__enum_values_by_name[4] =
+{
+  { "k_EBatteryState_Charging", 2 },
+  { "k_EBatteryState_Discharging", 1 },
+  { "k_EBatteryState_Full", 3 },
+  { "k_EBatteryState_Unknown", 0 },
+};
+const ProtobufCEnumDescriptor ebattery_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EBatteryState",
+  "EBatteryState",
+  "EBatteryState",
+  "",
+  4,
+  ebattery_state__enum_values_by_number,
+  4,
+  ebattery_state__enum_values_by_name,
+  1,
+  ebattery_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eosbranch__enum_values_by_number[7] =
+{
+  { "k_EOSBranch_Unknown", "EOSBRANCH__k_EOSBranch_Unknown", 0 },
+  { "k_EOSBranch_Release", "EOSBRANCH__k_EOSBranch_Release", 1 },
+  { "k_EOSBranch_ReleaseCandidate", "EOSBRANCH__k_EOSBranch_ReleaseCandidate", 2 },
+  { "k_EOSBranch_Beta", "EOSBRANCH__k_EOSBranch_Beta", 3 },
+  { "k_EOSBranch_BetaCandidate", "EOSBRANCH__k_EOSBranch_BetaCandidate", 4 },
+  { "k_EOSBranch_Main", "EOSBRANCH__k_EOSBranch_Main", 5 },
+  { "k_EOSBranch_Staging", "EOSBRANCH__k_EOSBranch_Staging", 6 },
+};
+static const ProtobufCIntRange eosbranch__value_ranges[] = {
+{0, 0},{0, 7}
+};
+static const ProtobufCEnumValueIndex eosbranch__enum_values_by_name[7] =
+{
+  { "k_EOSBranch_Beta", 3 },
+  { "k_EOSBranch_BetaCandidate", 4 },
+  { "k_EOSBranch_Main", 5 },
+  { "k_EOSBranch_Release", 1 },
+  { "k_EOSBranch_ReleaseCandidate", 2 },
+  { "k_EOSBranch_Staging", 6 },
+  { "k_EOSBranch_Unknown", 0 },
+};
+const ProtobufCEnumDescriptor eosbranch__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EOSBranch",
+  "EOSBranch",
+  "EOSBranch",
+  "",
+  7,
+  eosbranch__enum_values_by_number,
+  7,
+  eosbranch__enum_values_by_name,
+  1,
+  eosbranch__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue ecommunity_item_class__enum_values_by_number[18] =
+{
+  { "k_ECommunityItemClass_Invalid", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Invalid", 0 },
+  { "k_ECommunityItemClass_Badge", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Badge", 1 },
+  { "k_ECommunityItemClass_GameCard", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_GameCard", 2 },
+  { "k_ECommunityItemClass_ProfileBackground", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_ProfileBackground", 3 },
+  { "k_ECommunityItemClass_Emoticon", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Emoticon", 4 },
+  { "k_ECommunityItemClass_BoosterPack", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_BoosterPack", 5 },
+  { "k_ECommunityItemClass_Consumable", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Consumable", 6 },
+  { "k_ECommunityItemClass_GameGoo", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_GameGoo", 7 },
+  { "k_ECommunityItemClass_ProfileModifier", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_ProfileModifier", 8 },
+  { "k_ECommunityItemClass_Scene", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Scene", 9 },
+  { "k_ECommunityItemClass_SalienItem", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_SalienItem", 10 },
+  { "k_ECommunityItemClass_Sticker", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Sticker", 11 },
+  { "k_ECommunityItemClass_ChatEffect", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_ChatEffect", 12 },
+  { "k_ECommunityItemClass_MiniProfileBackground", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_MiniProfileBackground", 13 },
+  { "k_ECommunityItemClass_AvatarFrame", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_AvatarFrame", 14 },
+  { "k_ECommunityItemClass_AnimatedAvatar", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_AnimatedAvatar", 15 },
+  { "k_ECommunityItemClass_SteamDeckKeyboardSkin", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_SteamDeckKeyboardSkin", 16 },
+  { "k_ECommunityItemClass_SteamDeckStartupMovie", "ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_SteamDeckStartupMovie", 17 },
+};
+static const ProtobufCIntRange ecommunity_item_class__value_ranges[] = {
+{0, 0},{0, 18}
+};
+static const ProtobufCEnumValueIndex ecommunity_item_class__enum_values_by_name[18] =
+{
+  { "k_ECommunityItemClass_AnimatedAvatar", 15 },
+  { "k_ECommunityItemClass_AvatarFrame", 14 },
+  { "k_ECommunityItemClass_Badge", 1 },
+  { "k_ECommunityItemClass_BoosterPack", 5 },
+  { "k_ECommunityItemClass_ChatEffect", 12 },
+  { "k_ECommunityItemClass_Consumable", 6 },
+  { "k_ECommunityItemClass_Emoticon", 4 },
+  { "k_ECommunityItemClass_GameCard", 2 },
+  { "k_ECommunityItemClass_GameGoo", 7 },
+  { "k_ECommunityItemClass_Invalid", 0 },
+  { "k_ECommunityItemClass_MiniProfileBackground", 13 },
+  { "k_ECommunityItemClass_ProfileBackground", 3 },
+  { "k_ECommunityItemClass_ProfileModifier", 8 },
+  { "k_ECommunityItemClass_SalienItem", 10 },
+  { "k_ECommunityItemClass_Scene", 9 },
+  { "k_ECommunityItemClass_SteamDeckKeyboardSkin", 16 },
+  { "k_ECommunityItemClass_SteamDeckStartupMovie", 17 },
+  { "k_ECommunityItemClass_Sticker", 11 },
+};
+const ProtobufCEnumDescriptor ecommunity_item_class__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ECommunityItemClass",
+  "ECommunityItemClass",
+  "ECommunityItemClass",
+  "",
+  18,
+  ecommunity_item_class__enum_values_by_number,
+  18,
+  ecommunity_item_class__enum_values_by_name,
+  1,
+  ecommunity_item_class__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esteam_deck_compatibility_feedback__enum_values_by_number[4] =
+{
+  { "k_ESteamDeckCompatibilityFeedback_Unset", "ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Unset", 0 },
+  { "k_ESteamDeckCompatibilityFeedback_Agree", "ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Agree", 1 },
+  { "k_ESteamDeckCompatibilityFeedback_Disagree", "ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Disagree", 2 },
+  { "k_ESteamDeckCompatibilityFeedback_Ignore", "ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Ignore", 3 },
+};
+static const ProtobufCIntRange esteam_deck_compatibility_feedback__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex esteam_deck_compatibility_feedback__enum_values_by_name[4] =
+{
+  { "k_ESteamDeckCompatibilityFeedback_Agree", 1 },
+  { "k_ESteamDeckCompatibilityFeedback_Disagree", 2 },
+  { "k_ESteamDeckCompatibilityFeedback_Ignore", 3 },
+  { "k_ESteamDeckCompatibilityFeedback_Unset", 0 },
+};
+const ProtobufCEnumDescriptor esteam_deck_compatibility_feedback__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESteamDeckCompatibilityFeedback",
+  "ESteamDeckCompatibilityFeedback",
+  "ESteamDeckCompatibilityFeedback",
+  "",
+  4,
+  esteam_deck_compatibility_feedback__enum_values_by_number,
+  4,
+  esteam_deck_compatibility_feedback__enum_values_by_name,
+  1,
+  esteam_deck_compatibility_feedback__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eprovide_deck_feedback_preference__enum_values_by_number[3] =
+{
+  { "k_EProvideDeckFeedbackPreference_Unset", "EPROVIDE_DECK_FEEDBACK_PREFERENCE__k_EProvideDeckFeedbackPreference_Unset", 0 },
+  { "k_EProvideDeckFeedbackPreference_Yes", "EPROVIDE_DECK_FEEDBACK_PREFERENCE__k_EProvideDeckFeedbackPreference_Yes", 1 },
+  { "k_EProvideDeckFeedbackPreference_No", "EPROVIDE_DECK_FEEDBACK_PREFERENCE__k_EProvideDeckFeedbackPreference_No", 2 },
+};
+static const ProtobufCIntRange eprovide_deck_feedback_preference__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex eprovide_deck_feedback_preference__enum_values_by_name[3] =
+{
+  { "k_EProvideDeckFeedbackPreference_No", 2 },
+  { "k_EProvideDeckFeedbackPreference_Unset", 0 },
+  { "k_EProvideDeckFeedbackPreference_Yes", 1 },
+};
+const ProtobufCEnumDescriptor eprovide_deck_feedback_preference__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EProvideDeckFeedbackPreference",
+  "EProvideDeckFeedbackPreference",
+  "EProvideDeckFeedbackPreference",
+  "",
+  3,
+  eprovide_deck_feedback_preference__enum_values_by_number,
+  3,
+  eprovide_deck_feedback_preference__enum_values_by_name,
+  1,
+  eprovide_deck_feedback_preference__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue etouch_gesture__enum_values_by_number[14] =
+{
+  { "k_ETouchGestureNone", "ETOUCH_GESTURE__k_ETouchGestureNone", 0 },
+  { "k_ETouchGestureTouch", "ETOUCH_GESTURE__k_ETouchGestureTouch", 1 },
+  { "k_ETouchGestureTap", "ETOUCH_GESTURE__k_ETouchGestureTap", 2 },
+  { "k_ETouchGestureDoubleTap", "ETOUCH_GESTURE__k_ETouchGestureDoubleTap", 3 },
+  { "k_ETouchGestureShortPress", "ETOUCH_GESTURE__k_ETouchGestureShortPress", 4 },
+  { "k_ETouchGestureLongPress", "ETOUCH_GESTURE__k_ETouchGestureLongPress", 5 },
+  { "k_ETouchGestureLongTap", "ETOUCH_GESTURE__k_ETouchGestureLongTap", 6 },
+  { "k_ETouchGestureTwoFingerTap", "ETOUCH_GESTURE__k_ETouchGestureTwoFingerTap", 7 },
+  { "k_ETouchGestureTapCancelled", "ETOUCH_GESTURE__k_ETouchGestureTapCancelled", 8 },
+  { "k_ETouchGesturePinchBegin", "ETOUCH_GESTURE__k_ETouchGesturePinchBegin", 9 },
+  { "k_ETouchGesturePinchUpdate", "ETOUCH_GESTURE__k_ETouchGesturePinchUpdate", 10 },
+  { "k_ETouchGesturePinchEnd", "ETOUCH_GESTURE__k_ETouchGesturePinchEnd", 11 },
+  { "k_ETouchGestureFlingStart", "ETOUCH_GESTURE__k_ETouchGestureFlingStart", 12 },
+  { "k_ETouchGestureFlingCancelled", "ETOUCH_GESTURE__k_ETouchGestureFlingCancelled", 13 },
+};
+static const ProtobufCIntRange etouch_gesture__value_ranges[] = {
+{0, 0},{0, 14}
+};
+static const ProtobufCEnumValueIndex etouch_gesture__enum_values_by_name[14] =
+{
+  { "k_ETouchGestureDoubleTap", 3 },
+  { "k_ETouchGestureFlingCancelled", 13 },
+  { "k_ETouchGestureFlingStart", 12 },
+  { "k_ETouchGestureLongPress", 5 },
+  { "k_ETouchGestureLongTap", 6 },
+  { "k_ETouchGestureNone", 0 },
+  { "k_ETouchGesturePinchBegin", 9 },
+  { "k_ETouchGesturePinchEnd", 11 },
+  { "k_ETouchGesturePinchUpdate", 10 },
+  { "k_ETouchGestureShortPress", 4 },
+  { "k_ETouchGestureTap", 2 },
+  { "k_ETouchGestureTapCancelled", 8 },
+  { "k_ETouchGestureTouch", 1 },
+  { "k_ETouchGestureTwoFingerTap", 7 },
+};
+const ProtobufCEnumDescriptor etouch_gesture__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ETouchGesture",
+  "ETouchGesture",
+  "ETouchGesture",
+  "",
+  14,
+  etouch_gesture__enum_values_by_number,
+  14,
+  etouch_gesture__enum_values_by_name,
+  1,
+  etouch_gesture__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue esession_persistence__enum_values_by_number[3] =
+{
+  { "k_ESessionPersistence_Invalid", "ESESSION_PERSISTENCE__k_ESessionPersistence_Invalid", -1 },
+  { "k_ESessionPersistence_Ephemeral", "ESESSION_PERSISTENCE__k_ESessionPersistence_Ephemeral", 0 },
+  { "k_ESessionPersistence_Persistent", "ESESSION_PERSISTENCE__k_ESessionPersistence_Persistent", 1 },
+};
+static const ProtobufCIntRange esession_persistence__value_ranges[] = {
+{-1, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex esession_persistence__enum_values_by_name[3] =
+{
+  { "k_ESessionPersistence_Ephemeral", 1 },
+  { "k_ESessionPersistence_Invalid", 0 },
+  { "k_ESessionPersistence_Persistent", 2 },
+};
+const ProtobufCEnumDescriptor esession_persistence__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ESessionPersistence",
+  "ESessionPersistence",
+  "ESessionPersistence",
+  "",
+  3,
+  esession_persistence__enum_values_by_number,
+  3,
+  esession_persistence__enum_values_by_name,
+  1,
+  esession_persistence__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue enew_steam_announcement_state__enum_values_by_number[4] =
+{
+  { "k_ENewSteamAnnouncementState_Invalid", "ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_Invalid", 0 },
+  { "k_ENewSteamAnnouncementState_AllRead", "ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_AllRead", 1 },
+  { "k_ENewSteamAnnouncementState_NewAnnouncement", "ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_NewAnnouncement", 2 },
+  { "k_ENewSteamAnnouncementState_FeaturedAnnouncement", "ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_FeaturedAnnouncement", 3 },
+};
+static const ProtobufCIntRange enew_steam_announcement_state__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex enew_steam_announcement_state__enum_values_by_name[4] =
+{
+  { "k_ENewSteamAnnouncementState_AllRead", 1 },
+  { "k_ENewSteamAnnouncementState_FeaturedAnnouncement", 3 },
+  { "k_ENewSteamAnnouncementState_Invalid", 0 },
+  { "k_ENewSteamAnnouncementState_NewAnnouncement", 2 },
+};
+const ProtobufCEnumDescriptor enew_steam_announcement_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ENewSteamAnnouncementState",
+  "ENewSteamAnnouncementState",
+  "ENewSteamAnnouncementState",
+  "",
+  4,
+  enew_steam_announcement_state__enum_values_by_number,
+  4,
+  enew_steam_announcement_state__enum_values_by_name,
+  1,
+  enew_steam_announcement_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
diff --git a/protocols/Steam/src/protobuf-c/enums.pb-c.h b/protocols/Steam/src/protobuf-c/enums.pb-c.h
new file mode 100644
index 0000000000..6a944cffac
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/enums.pb-c.h
@@ -0,0 +1,462 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: enums.proto */
+
+#ifndef PROTOBUF_C_enums_2eproto__INCLUDED
+#define PROTOBUF_C_enums_2eproto__INCLUDED
+
+#include "protobuf-c.h"
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1000000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "steammessages_base.pb-c.h"
+
+/* --- enums --- */
+
+typedef enum _EPublishedFileQueryType {
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByVote = 0,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByPublicationDate = 1,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_AcceptedForGameRankedByAcceptanceDate = 2,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTrend = 3,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_FavoritedByFriendsRankedByPublicationDate = 4,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_CreatedByFriendsRankedByPublicationDate = 5,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByNumTimesReported = 6,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_CreatedByFollowedUsersRankedByPublicationDate = 7,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_NotYetRated = 8,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTotalUniqueSubscriptions = 9,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTotalVotesAsc = 10,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByVotesUp = 11,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTextSearch = 12,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByPlaytimeTrend = 13,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByTotalPlaytime = 14,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByAveragePlaytimeTrend = 15,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByLifetimeAveragePlaytime = 16,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByPlaytimeSessionsTrend = 17,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByLifetimePlaytimeSessions = 18,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByInappropriateContentRating = 19,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByBanContentCheck = 20,
+  EPUBLISHED_FILE_QUERY_TYPE__k_PublishedFileQueryType_RankedByLastUpdatedDate = 21
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPUBLISHED_FILE_QUERY_TYPE)
+} EPublishedFileQueryType;
+typedef enum _EPublishedFileInappropriateProvider {
+  EPUBLISHED_FILE_INAPPROPRIATE_PROVIDER__k_EPublishedFileInappropriateProvider_Invalid = 0,
+  EPUBLISHED_FILE_INAPPROPRIATE_PROVIDER__k_EPublishedFileInappropriateProvider_Google = 1,
+  EPUBLISHED_FILE_INAPPROPRIATE_PROVIDER__k_EPublishedFileInappropriateProvider_Amazon = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPUBLISHED_FILE_INAPPROPRIATE_PROVIDER)
+} EPublishedFileInappropriateProvider;
+typedef enum _EPublishedFileInappropriateResult {
+  EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_NotScanned = 0,
+  EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_VeryUnlikely = 1,
+  EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_Unlikely = 30,
+  EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_Possible = 50,
+  EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_Likely = 75,
+  EPUBLISHED_FILE_INAPPROPRIATE_RESULT__k_EPublishedFileInappropriateResult_VeryLikely = 100
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPUBLISHED_FILE_INAPPROPRIATE_RESULT)
+} EPublishedFileInappropriateResult;
+typedef enum _EPersonaStateFlag {
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_HasRichPresence = 1,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_InJoinableGame = 2,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_Golden = 4,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_RemotePlayTogether = 8,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeWeb = 256,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeMobile = 512,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeTenfoot = 1024,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_ClientTypeVR = 2048,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_LaunchTypeGamepad = 4096,
+  EPERSONA_STATE_FLAG__k_EPersonaStateFlag_LaunchTypeCompatTool = 8192
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPERSONA_STATE_FLAG)
+} EPersonaStateFlag;
+typedef enum _EContentCheckProvider {
+  ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Invalid = 0,
+  ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Google = 1,
+  ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Amazon = 2,
+  ECONTENT_CHECK_PROVIDER__k_EContentCheckProvider_Local = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ECONTENT_CHECK_PROVIDER)
+} EContentCheckProvider;
+typedef enum _EProfileCustomizationType {
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeInvalid = 0,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeRareAchievementShowcase = 1,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeGameCollector = 2,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeItemShowcase = 3,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeTradeShowcase = 4,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeBadges = 5,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeFavoriteGame = 6,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeScreenshotShowcase = 7,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeCustomText = 8,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeFavoriteGroup = 9,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeRecommendation = 10,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeWorkshopItem = 11,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeMyWorkshop = 12,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeArtworkShowcase = 13,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeVideoShowcase = 14,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeGuides = 15,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeMyGuides = 16,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeAchievements = 17,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeGreenlight = 18,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeMyGreenlight = 19,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeSalien = 20,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeLoyaltyRewardReactions = 21,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeSingleArtworkShowcase = 22,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeAchievementsCompletionist = 23,
+  EPROFILE_CUSTOMIZATION_TYPE__k_EProfileCustomizationTypeReplay = 24
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPROFILE_CUSTOMIZATION_TYPE)
+} EProfileCustomizationType;
+typedef enum _EPublishedFileStorageSystem {
+  EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemInvalid = 0,
+  EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemLegacyCloud = 1,
+  EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemDepot = 2,
+  EPUBLISHED_FILE_STORAGE_SYSTEM__k_EPublishedFileStorageSystemUGCCloud = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPUBLISHED_FILE_STORAGE_SYSTEM)
+} EPublishedFileStorageSystem;
+typedef enum _ECloudStoragePersistState {
+  ECLOUD_STORAGE_PERSIST_STATE__k_ECloudStoragePersistStatePersisted = 0,
+  ECLOUD_STORAGE_PERSIST_STATE__k_ECloudStoragePersistStateForgotten = 1,
+  ECLOUD_STORAGE_PERSIST_STATE__k_ECloudStoragePersistStateDeleted = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ECLOUD_STORAGE_PERSIST_STATE)
+} ECloudStoragePersistState;
+typedef enum _ESDCardFormatStage {
+  ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Invalid = 0,
+  ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Starting = 1,
+  ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Testing = 2,
+  ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Rescuing = 3,
+  ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Formatting = 4,
+  ESDCARD_FORMAT_STAGE__k_ESDCardFormatStage_Finalizing = 5
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESDCARD_FORMAT_STAGE)
+} ESDCardFormatStage;
+typedef enum _ESystemFanControlMode {
+  ESYSTEM_FAN_CONTROL_MODE__k_SystemFanControlMode_Invalid = 0,
+  ESYSTEM_FAN_CONTROL_MODE__k_SystemFanControlMode_Disabled = 1,
+  ESYSTEM_FAN_CONTROL_MODE__k_SystemFanControlMode_Default = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESYSTEM_FAN_CONTROL_MODE)
+} ESystemFanControlMode;
+typedef enum _EColorProfile {
+  ECOLOR_PROFILE__k_EColorProfile_Invalid = 0,
+  ECOLOR_PROFILE__k_EColorProfile_Native = 1,
+  ECOLOR_PROFILE__k_EColorProfile_Standard = 2,
+  ECOLOR_PROFILE__k_EColorProfile_Vivid = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ECOLOR_PROFILE)
+} EColorProfile;
+typedef enum _EBluetoothDeviceType {
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Invalid = 0,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Unknown = 1,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Phone = 2,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Computer = 3,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Headset = 4,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Headphones = 5,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Speakers = 6,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_OtherAudio = 7,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Mouse = 8,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Joystick = 9,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Gamepad = 10,
+  EBLUETOOTH_DEVICE_TYPE__k_BluetoothDeviceType_Keyboard = 11
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EBLUETOOTH_DEVICE_TYPE)
+} EBluetoothDeviceType;
+typedef enum _ESystemAudioDirection {
+  ESYSTEM_AUDIO_DIRECTION__k_SystemAudioDirection_Invalid = 0,
+  ESYSTEM_AUDIO_DIRECTION__k_SystemAudioDirection_Input = 1,
+  ESYSTEM_AUDIO_DIRECTION__k_SystemAudioDirection_Output = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESYSTEM_AUDIO_DIRECTION)
+} ESystemAudioDirection;
+typedef enum _ESystemAudioChannel {
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Invalid = 0,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Aggregated = 1,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_FrontLeft = 2,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_FrontRight = 3,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_LFE = 4,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_BackLeft = 5,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_BackRight = 6,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_FrontCenter = 7,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Unknown = 8,
+  ESYSTEM_AUDIO_CHANNEL__k_SystemAudioChannel_Mono = 9
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESYSTEM_AUDIO_CHANNEL)
+} ESystemAudioChannel;
+typedef enum _ESystemAudioPortType {
+  ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Invalid = 0,
+  ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Unknown = 1,
+  ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Audio32f = 2,
+  ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Midi8b = 3,
+  ESYSTEM_AUDIO_PORT_TYPE__k_SystemAudioPortType_Video32RGBA = 4
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESYSTEM_AUDIO_PORT_TYPE)
+} ESystemAudioPortType;
+typedef enum _ESystemAudioPortDirection {
+  ESYSTEM_AUDIO_PORT_DIRECTION__k_SystemAudioPortDirection_Invalid = 0,
+  ESYSTEM_AUDIO_PORT_DIRECTION__k_SystemAudioPortDirection_Input = 1,
+  ESYSTEM_AUDIO_PORT_DIRECTION__k_SystemAudioPortDirection_Output = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESYSTEM_AUDIO_PORT_DIRECTION)
+} ESystemAudioPortDirection;
+typedef enum _ESystemServiceState {
+  ESYSTEM_SERVICE_STATE__k_ESystemServiceState_Unavailable = 0,
+  ESYSTEM_SERVICE_STATE__k_ESystemServiceState_Disabled = 1,
+  ESYSTEM_SERVICE_STATE__k_ESystemServiceState_Enabled = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESYSTEM_SERVICE_STATE)
+} ESystemServiceState;
+typedef enum _EGraphicsPerfOverlayLevel {
+  EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Hidden = 0,
+  EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Basic = 1,
+  EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Medium = 2,
+  EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Full = 3,
+  EGRAPHICS_PERF_OVERLAY_LEVEL__k_EGraphicsPerfOverlayLevel_Minimal = 4
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EGRAPHICS_PERF_OVERLAY_LEVEL)
+} EGraphicsPerfOverlayLevel;
+typedef enum _EGPUPerformanceLevel {
+  EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Invalid = 0,
+  EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Auto = 1,
+  EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Manual = 2,
+  EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Low = 3,
+  EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_High = 4,
+  EGPUPERFORMANCE_LEVEL__k_EGPUPerformanceLevel_Profiling = 5
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EGPUPERFORMANCE_LEVEL)
+} EGPUPerformanceLevel;
+typedef enum _EScalingFilter {
+  ESCALING_FILTER__k_EScalingFilter_Invalid = 0,
+  ESCALING_FILTER__k_EScalingFilter_FSR = 1,
+  ESCALING_FILTER__k_EScalingFilter_Nearest = 2,
+  ESCALING_FILTER__k_EScalingFilter_Integer = 3,
+  ESCALING_FILTER__k_EScalingFilter_Linear = 4,
+  ESCALING_FILTER__k_EScalingFilter_NIS = 5
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESCALING_FILTER)
+} EScalingFilter;
+typedef enum _ESplitScalingFilter {
+  ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_Invalid = 0,
+  ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_Linear = 1,
+  ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_Nearest = 2,
+  ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_FSR = 3,
+  ESPLIT_SCALING_FILTER__k_ESplitScalingFilter_NIS = 4
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESPLIT_SCALING_FILTER)
+} ESplitScalingFilter;
+typedef enum _ESplitScalingScaler {
+  ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Invalid = 0,
+  ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Auto = 1,
+  ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Integer = 2,
+  ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Fit = 3,
+  ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Fill = 4,
+  ESPLIT_SCALING_SCALER__k_ESplitScalingScaler_Stretch = 5
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESPLIT_SCALING_SCALER)
+} ESplitScalingScaler;
+typedef enum _EHDRToneMapOperator {
+  EHDRTONE_MAP_OPERATOR__k_EHDRToneMapOperator_Invalid = 0,
+  EHDRTONE_MAP_OPERATOR__k_EHDRToneMapOperator_Uncharted = 1,
+  EHDRTONE_MAP_OPERATOR__k_EHDRToneMapOperator_Reinhard = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EHDRTONE_MAP_OPERATOR)
+} EHDRToneMapOperator;
+typedef enum _ECPUGovernor {
+  ECPUGOVERNOR__k_ECPUGovernor_Invalid = 0,
+  ECPUGOVERNOR__k_ECPUGovernor_Perf = 1,
+  ECPUGOVERNOR__k_ECPUGovernor_Powersave = 2,
+  ECPUGOVERNOR__k_ECPUGovernor_Manual = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ECPUGOVERNOR)
+} ECPUGovernor;
+typedef enum _EUpdaterType {
+  EUPDATER_TYPE__k_EUpdaterType_Invalid = 0,
+  EUPDATER_TYPE__k_EUpdaterType_Client = 1,
+  EUPDATER_TYPE__k_EUpdaterType_OS = 2,
+  EUPDATER_TYPE__k_EUpdaterType_BIOS = 3,
+  EUPDATER_TYPE__k_EUpdaterType_Aggregated = 4,
+  EUPDATER_TYPE__k_EUpdaterType_Test1 = 5,
+  EUPDATER_TYPE__k_EUpdaterType_Test2 = 6,
+  EUPDATER_TYPE__k_EUpdaterType_Dummy = 7
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EUPDATER_TYPE)
+} EUpdaterType;
+typedef enum _EUpdaterState {
+  EUPDATER_STATE__k_EUpdaterState_Invalid = 0,
+  EUPDATER_STATE__k_EUpdaterState_UpToDate = 2,
+  EUPDATER_STATE__k_EUpdaterState_Checking = 3,
+  EUPDATER_STATE__k_EUpdaterState_Available = 4,
+  EUPDATER_STATE__k_EUpdaterState_Applying = 5,
+  EUPDATER_STATE__k_EUpdaterState_ClientRestartPending = 6,
+  EUPDATER_STATE__k_EUpdaterState_SystemRestartPending = 7
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EUPDATER_STATE)
+} EUpdaterState;
+typedef enum _EStorageBlockContentType {
+  ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Invalid = 0,
+  ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Unknown = 1,
+  ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_FileSystem = 2,
+  ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Crypto = 3,
+  ESTORAGE_BLOCK_CONTENT_TYPE__k_EStorageBlockContentType_Raid = 4
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESTORAGE_BLOCK_CONTENT_TYPE)
+} EStorageBlockContentType;
+typedef enum _EStorageBlockFileSystemType {
+  ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_Invalid = 0,
+  ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_Unknown = 1,
+  ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_VFat = 2,
+  ESTORAGE_BLOCK_FILE_SYSTEM_TYPE__k_EStorageBlockFileSystemType_Ext4 = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESTORAGE_BLOCK_FILE_SYSTEM_TYPE)
+} EStorageBlockFileSystemType;
+typedef enum _EStorageDriveMediaType {
+  ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_Invalid = 0,
+  ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_Unknown = 1,
+  ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_HDD = 2,
+  ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_SSD = 3,
+  ESTORAGE_DRIVE_MEDIA_TYPE__k_EStorageDriveMediaType_Removable = 4
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESTORAGE_DRIVE_MEDIA_TYPE)
+} EStorageDriveMediaType;
+typedef enum _ESystemDisplayCompatibilityMode {
+  ESYSTEM_DISPLAY_COMPATIBILITY_MODE__k_ESystemDisplayCompatibilityMode_Invalid = 0,
+  ESYSTEM_DISPLAY_COMPATIBILITY_MODE__k_ESystemDisplayCompatibilityMode_None = 1,
+  ESYSTEM_DISPLAY_COMPATIBILITY_MODE__k_ESystemDisplayCompatibilityMode_MinimalBandwith = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESYSTEM_DISPLAY_COMPATIBILITY_MODE)
+} ESystemDisplayCompatibilityMode;
+typedef enum _ESteamDeckCompatibilityCategory {
+  ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Unknown = 0,
+  ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Unsupported = 1,
+  ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Playable = 2,
+  ESTEAM_DECK_COMPATIBILITY_CATEGORY__k_ESteamDeckCompatibilityCategory_Verified = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESTEAM_DECK_COMPATIBILITY_CATEGORY)
+} ESteamDeckCompatibilityCategory;
+typedef enum _ESteamDeckCompatibilityResultDisplayType {
+  ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Invisible = 0,
+  ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Informational = 1,
+  ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Unsupported = 2,
+  ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Playable = 3,
+  ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE__k_ESteamDeckCompatibilityResultDisplayType_Verified = 4
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESTEAM_DECK_COMPATIBILITY_RESULT_DISPLAY_TYPE)
+} ESteamDeckCompatibilityResultDisplayType;
+typedef enum _EACState {
+  EACSTATE__k_EACState_Unknown = 0,
+  EACSTATE__k_EACState_Disconnected = 1,
+  EACSTATE__k_EACState_Connected = 2,
+  EACSTATE__k_EACState_ConnectedSlow = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EACSTATE)
+} EACState;
+typedef enum _EBatteryState {
+  EBATTERY_STATE__k_EBatteryState_Unknown = 0,
+  EBATTERY_STATE__k_EBatteryState_Discharging = 1,
+  EBATTERY_STATE__k_EBatteryState_Charging = 2,
+  EBATTERY_STATE__k_EBatteryState_Full = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EBATTERY_STATE)
+} EBatteryState;
+typedef enum _EOSBranch {
+  EOSBRANCH__k_EOSBranch_Unknown = 0,
+  EOSBRANCH__k_EOSBranch_Release = 1,
+  EOSBRANCH__k_EOSBranch_ReleaseCandidate = 2,
+  EOSBRANCH__k_EOSBranch_Beta = 3,
+  EOSBRANCH__k_EOSBranch_BetaCandidate = 4,
+  EOSBRANCH__k_EOSBranch_Main = 5,
+  EOSBRANCH__k_EOSBranch_Staging = 6
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EOSBRANCH)
+} EOSBranch;
+typedef enum _ECommunityItemClass {
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Invalid = 0,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Badge = 1,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_GameCard = 2,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_ProfileBackground = 3,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Emoticon = 4,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_BoosterPack = 5,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Consumable = 6,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_GameGoo = 7,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_ProfileModifier = 8,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Scene = 9,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_SalienItem = 10,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_Sticker = 11,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_ChatEffect = 12,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_MiniProfileBackground = 13,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_AvatarFrame = 14,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_AnimatedAvatar = 15,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_SteamDeckKeyboardSkin = 16,
+  ECOMMUNITY_ITEM_CLASS__k_ECommunityItemClass_SteamDeckStartupMovie = 17
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ECOMMUNITY_ITEM_CLASS)
+} ECommunityItemClass;
+typedef enum _ESteamDeckCompatibilityFeedback {
+  ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Unset = 0,
+  ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Agree = 1,
+  ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Disagree = 2,
+  ESTEAM_DECK_COMPATIBILITY_FEEDBACK__k_ESteamDeckCompatibilityFeedback_Ignore = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESTEAM_DECK_COMPATIBILITY_FEEDBACK)
+} ESteamDeckCompatibilityFeedback;
+typedef enum _EProvideDeckFeedbackPreference {
+  EPROVIDE_DECK_FEEDBACK_PREFERENCE__k_EProvideDeckFeedbackPreference_Unset = 0,
+  EPROVIDE_DECK_FEEDBACK_PREFERENCE__k_EProvideDeckFeedbackPreference_Yes = 1,
+  EPROVIDE_DECK_FEEDBACK_PREFERENCE__k_EProvideDeckFeedbackPreference_No = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPROVIDE_DECK_FEEDBACK_PREFERENCE)
+} EProvideDeckFeedbackPreference;
+typedef enum _ETouchGesture {
+  ETOUCH_GESTURE__k_ETouchGestureNone = 0,
+  ETOUCH_GESTURE__k_ETouchGestureTouch = 1,
+  ETOUCH_GESTURE__k_ETouchGestureTap = 2,
+  ETOUCH_GESTURE__k_ETouchGestureDoubleTap = 3,
+  ETOUCH_GESTURE__k_ETouchGestureShortPress = 4,
+  ETOUCH_GESTURE__k_ETouchGestureLongPress = 5,
+  ETOUCH_GESTURE__k_ETouchGestureLongTap = 6,
+  ETOUCH_GESTURE__k_ETouchGestureTwoFingerTap = 7,
+  ETOUCH_GESTURE__k_ETouchGestureTapCancelled = 8,
+  ETOUCH_GESTURE__k_ETouchGesturePinchBegin = 9,
+  ETOUCH_GESTURE__k_ETouchGesturePinchUpdate = 10,
+  ETOUCH_GESTURE__k_ETouchGesturePinchEnd = 11,
+  ETOUCH_GESTURE__k_ETouchGestureFlingStart = 12,
+  ETOUCH_GESTURE__k_ETouchGestureFlingCancelled = 13
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETOUCH_GESTURE)
+} ETouchGesture;
+typedef enum _ESessionPersistence {
+  ESESSION_PERSISTENCE__k_ESessionPersistence_Invalid = -1,
+  ESESSION_PERSISTENCE__k_ESessionPersistence_Ephemeral = 0,
+  ESESSION_PERSISTENCE__k_ESessionPersistence_Persistent = 1
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ESESSION_PERSISTENCE)
+} ESessionPersistence;
+typedef enum _ENewSteamAnnouncementState {
+  ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_Invalid = 0,
+  ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_AllRead = 1,
+  ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_NewAnnouncement = 2,
+  ENEW_STEAM_ANNOUNCEMENT_STATE__k_ENewSteamAnnouncementState_FeaturedAnnouncement = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ENEW_STEAM_ANNOUNCEMENT_STATE)
+} ENewSteamAnnouncementState;
+
+/* --- descriptors --- */
+
+extern const ProtobufCEnumDescriptor    epublished_file_query_type__descriptor;
+extern const ProtobufCEnumDescriptor    epublished_file_inappropriate_provider__descriptor;
+extern const ProtobufCEnumDescriptor    epublished_file_inappropriate_result__descriptor;
+extern const ProtobufCEnumDescriptor    epersona_state_flag__descriptor;
+extern const ProtobufCEnumDescriptor    econtent_check_provider__descriptor;
+extern const ProtobufCEnumDescriptor    eprofile_customization_type__descriptor;
+extern const ProtobufCEnumDescriptor    epublished_file_storage_system__descriptor;
+extern const ProtobufCEnumDescriptor    ecloud_storage_persist_state__descriptor;
+extern const ProtobufCEnumDescriptor    esdcard_format_stage__descriptor;
+extern const ProtobufCEnumDescriptor    esystem_fan_control_mode__descriptor;
+extern const ProtobufCEnumDescriptor    ecolor_profile__descriptor;
+extern const ProtobufCEnumDescriptor    ebluetooth_device_type__descriptor;
+extern const ProtobufCEnumDescriptor    esystem_audio_direction__descriptor;
+extern const ProtobufCEnumDescriptor    esystem_audio_channel__descriptor;
+extern const ProtobufCEnumDescriptor    esystem_audio_port_type__descriptor;
+extern const ProtobufCEnumDescriptor    esystem_audio_port_direction__descriptor;
+extern const ProtobufCEnumDescriptor    esystem_service_state__descriptor;
+extern const ProtobufCEnumDescriptor    egraphics_perf_overlay_level__descriptor;
+extern const ProtobufCEnumDescriptor    egpuperformance_level__descriptor;
+extern const ProtobufCEnumDescriptor    escaling_filter__descriptor;
+extern const ProtobufCEnumDescriptor    esplit_scaling_filter__descriptor;
+extern const ProtobufCEnumDescriptor    esplit_scaling_scaler__descriptor;
+extern const ProtobufCEnumDescriptor    ehdrtone_map_operator__descriptor;
+extern const ProtobufCEnumDescriptor    ecpugovernor__descriptor;
+extern const ProtobufCEnumDescriptor    eupdater_type__descriptor;
+extern const ProtobufCEnumDescriptor    eupdater_state__descriptor;
+extern const ProtobufCEnumDescriptor    estorage_block_content_type__descriptor;
+extern const ProtobufCEnumDescriptor    estorage_block_file_system_type__descriptor;
+extern const ProtobufCEnumDescriptor    estorage_drive_media_type__descriptor;
+extern const ProtobufCEnumDescriptor    esystem_display_compatibility_mode__descriptor;
+extern const ProtobufCEnumDescriptor    esteam_deck_compatibility_category__descriptor;
+extern const ProtobufCEnumDescriptor    esteam_deck_compatibility_result_display_type__descriptor;
+extern const ProtobufCEnumDescriptor    eacstate__descriptor;
+extern const ProtobufCEnumDescriptor    ebattery_state__descriptor;
+extern const ProtobufCEnumDescriptor    eosbranch__descriptor;
+extern const ProtobufCEnumDescriptor    ecommunity_item_class__descriptor;
+extern const ProtobufCEnumDescriptor    esteam_deck_compatibility_feedback__descriptor;
+extern const ProtobufCEnumDescriptor    eprovide_deck_feedback_preference__descriptor;
+extern const ProtobufCEnumDescriptor    etouch_gesture__descriptor;
+extern const ProtobufCEnumDescriptor    esession_persistence__descriptor;
+extern const ProtobufCEnumDescriptor    enew_steam_announcement_state__descriptor;
+
+/* --- messages --- */
+
+/* --- per-message closures --- */
+
+/* --- services --- */
+
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_enums_2eproto__INCLUDED */
diff --git a/protocols/Steam/src/protobuf-c/enums.proto b/protocols/Steam/src/protobuf-c/enums.proto
new file mode 100644
index 0000000000..d36d4d1bdf
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/enums.proto
@@ -0,0 +1,391 @@
+import "steammessages_base.proto";
+
+option optimize_for = SPEED;
+option cc_generic_services = true;
+option (force_php_generation) = true;
+
+enum EPublishedFileQueryType {
+	k_PublishedFileQueryType_RankedByVote = 0;
+	k_PublishedFileQueryType_RankedByPublicationDate = 1;
+	k_PublishedFileQueryType_AcceptedForGameRankedByAcceptanceDate = 2;
+	k_PublishedFileQueryType_RankedByTrend = 3;
+	k_PublishedFileQueryType_FavoritedByFriendsRankedByPublicationDate = 4;
+	k_PublishedFileQueryType_CreatedByFriendsRankedByPublicationDate = 5;
+	k_PublishedFileQueryType_RankedByNumTimesReported = 6;
+	k_PublishedFileQueryType_CreatedByFollowedUsersRankedByPublicationDate = 7;
+	k_PublishedFileQueryType_NotYetRated = 8;
+	k_PublishedFileQueryType_RankedByTotalUniqueSubscriptions = 9;
+	k_PublishedFileQueryType_RankedByTotalVotesAsc = 10;
+	k_PublishedFileQueryType_RankedByVotesUp = 11;
+	k_PublishedFileQueryType_RankedByTextSearch = 12;
+	k_PublishedFileQueryType_RankedByPlaytimeTrend = 13;
+	k_PublishedFileQueryType_RankedByTotalPlaytime = 14;
+	k_PublishedFileQueryType_RankedByAveragePlaytimeTrend = 15;
+	k_PublishedFileQueryType_RankedByLifetimeAveragePlaytime = 16;
+	k_PublishedFileQueryType_RankedByPlaytimeSessionsTrend = 17;
+	k_PublishedFileQueryType_RankedByLifetimePlaytimeSessions = 18;
+	k_PublishedFileQueryType_RankedByInappropriateContentRating = 19;
+	k_PublishedFileQueryType_RankedByBanContentCheck = 20;
+	k_PublishedFileQueryType_RankedByLastUpdatedDate = 21;
+}
+
+enum EPublishedFileInappropriateProvider {
+	k_EPublishedFileInappropriateProvider_Invalid = 0;
+	k_EPublishedFileInappropriateProvider_Google = 1;
+	k_EPublishedFileInappropriateProvider_Amazon = 2;
+}
+
+enum EPublishedFileInappropriateResult {
+	k_EPublishedFileInappropriateResult_NotScanned = 0;
+	k_EPublishedFileInappropriateResult_VeryUnlikely = 1;
+	k_EPublishedFileInappropriateResult_Unlikely = 30;
+	k_EPublishedFileInappropriateResult_Possible = 50;
+	k_EPublishedFileInappropriateResult_Likely = 75;
+	k_EPublishedFileInappropriateResult_VeryLikely = 100;
+}
+
+enum EPersonaStateFlag {
+	k_EPersonaStateFlag_HasRichPresence = 1;
+	k_EPersonaStateFlag_InJoinableGame = 2;
+	k_EPersonaStateFlag_Golden = 4;
+	k_EPersonaStateFlag_RemotePlayTogether = 8;
+	k_EPersonaStateFlag_ClientTypeWeb = 256;
+	k_EPersonaStateFlag_ClientTypeMobile = 512;
+	k_EPersonaStateFlag_ClientTypeTenfoot = 1024;
+	k_EPersonaStateFlag_ClientTypeVR = 2048;
+	k_EPersonaStateFlag_LaunchTypeGamepad = 4096;
+	k_EPersonaStateFlag_LaunchTypeCompatTool = 8192;
+}
+
+enum EContentCheckProvider {
+	k_EContentCheckProvider_Invalid = 0;
+	k_EContentCheckProvider_Google = 1;
+	k_EContentCheckProvider_Amazon = 2;
+	k_EContentCheckProvider_Local = 3;
+}
+
+enum EProfileCustomizationType {
+	k_EProfileCustomizationTypeInvalid = 0;
+	k_EProfileCustomizationTypeRareAchievementShowcase = 1;
+	k_EProfileCustomizationTypeGameCollector = 2;
+	k_EProfileCustomizationTypeItemShowcase = 3;
+	k_EProfileCustomizationTypeTradeShowcase = 4;
+	k_EProfileCustomizationTypeBadges = 5;
+	k_EProfileCustomizationTypeFavoriteGame = 6;
+	k_EProfileCustomizationTypeScreenshotShowcase = 7;
+	k_EProfileCustomizationTypeCustomText = 8;
+	k_EProfileCustomizationTypeFavoriteGroup = 9;
+	k_EProfileCustomizationTypeRecommendation = 10;
+	k_EProfileCustomizationTypeWorkshopItem = 11;
+	k_EProfileCustomizationTypeMyWorkshop = 12;
+	k_EProfileCustomizationTypeArtworkShowcase = 13;
+	k_EProfileCustomizationTypeVideoShowcase = 14;
+	k_EProfileCustomizationTypeGuides = 15;
+	k_EProfileCustomizationTypeMyGuides = 16;
+	k_EProfileCustomizationTypeAchievements = 17;
+	k_EProfileCustomizationTypeGreenlight = 18;
+	k_EProfileCustomizationTypeMyGreenlight = 19;
+	k_EProfileCustomizationTypeSalien = 20;
+	k_EProfileCustomizationTypeLoyaltyRewardReactions = 21;
+	k_EProfileCustomizationTypeSingleArtworkShowcase = 22;
+	k_EProfileCustomizationTypeAchievementsCompletionist = 23;
+	k_EProfileCustomizationTypeReplay = 24;
+}
+
+enum EPublishedFileStorageSystem {
+	k_EPublishedFileStorageSystemInvalid = 0;
+	k_EPublishedFileStorageSystemLegacyCloud = 1;
+	k_EPublishedFileStorageSystemDepot = 2;
+	k_EPublishedFileStorageSystemUGCCloud = 3;
+}
+
+enum ECloudStoragePersistState {
+	k_ECloudStoragePersistStatePersisted = 0;
+	k_ECloudStoragePersistStateForgotten = 1;
+	k_ECloudStoragePersistStateDeleted = 2;
+}
+
+enum ESDCardFormatStage {
+	k_ESDCardFormatStage_Invalid = 0;
+	k_ESDCardFormatStage_Starting = 1;
+	k_ESDCardFormatStage_Testing = 2;
+	k_ESDCardFormatStage_Rescuing = 3;
+	k_ESDCardFormatStage_Formatting = 4;
+	k_ESDCardFormatStage_Finalizing = 5;
+}
+
+enum ESystemFanControlMode {
+	k_SystemFanControlMode_Invalid = 0;
+	k_SystemFanControlMode_Disabled = 1;
+	k_SystemFanControlMode_Default = 2;
+}
+
+enum EColorProfile {
+	k_EColorProfile_Invalid = 0;
+	k_EColorProfile_Native = 1;
+	k_EColorProfile_Standard = 2;
+	k_EColorProfile_Vivid = 3;
+}
+
+enum EBluetoothDeviceType {
+	k_BluetoothDeviceType_Invalid = 0;
+	k_BluetoothDeviceType_Unknown = 1;
+	k_BluetoothDeviceType_Phone = 2;
+	k_BluetoothDeviceType_Computer = 3;
+	k_BluetoothDeviceType_Headset = 4;
+	k_BluetoothDeviceType_Headphones = 5;
+	k_BluetoothDeviceType_Speakers = 6;
+	k_BluetoothDeviceType_OtherAudio = 7;
+	k_BluetoothDeviceType_Mouse = 8;
+	k_BluetoothDeviceType_Joystick = 9;
+	k_BluetoothDeviceType_Gamepad = 10;
+	k_BluetoothDeviceType_Keyboard = 11;
+}
+
+enum ESystemAudioDirection {
+	k_SystemAudioDirection_Invalid = 0;
+	k_SystemAudioDirection_Input = 1;
+	k_SystemAudioDirection_Output = 2;
+}
+
+enum ESystemAudioChannel {
+	k_SystemAudioChannel_Invalid = 0;
+	k_SystemAudioChannel_Aggregated = 1;
+	k_SystemAudioChannel_FrontLeft = 2;
+	k_SystemAudioChannel_FrontRight = 3;
+	k_SystemAudioChannel_LFE = 4;
+	k_SystemAudioChannel_BackLeft = 5;
+	k_SystemAudioChannel_BackRight = 6;
+	k_SystemAudioChannel_FrontCenter = 7;
+	k_SystemAudioChannel_Unknown = 8;
+	k_SystemAudioChannel_Mono = 9;
+}
+
+enum ESystemAudioPortType {
+	k_SystemAudioPortType_Invalid = 0;
+	k_SystemAudioPortType_Unknown = 1;
+	k_SystemAudioPortType_Audio32f = 2;
+	k_SystemAudioPortType_Midi8b = 3;
+	k_SystemAudioPortType_Video32RGBA = 4;
+}
+
+enum ESystemAudioPortDirection {
+	k_SystemAudioPortDirection_Invalid = 0;
+	k_SystemAudioPortDirection_Input = 1;
+	k_SystemAudioPortDirection_Output = 2;
+}
+
+enum ESystemServiceState {
+	k_ESystemServiceState_Unavailable = 0;
+	k_ESystemServiceState_Disabled = 1;
+	k_ESystemServiceState_Enabled = 2;
+}
+
+enum EGraphicsPerfOverlayLevel {
+	k_EGraphicsPerfOverlayLevel_Hidden = 0;
+	k_EGraphicsPerfOverlayLevel_Basic = 1;
+	k_EGraphicsPerfOverlayLevel_Medium = 2;
+	k_EGraphicsPerfOverlayLevel_Full = 3;
+	k_EGraphicsPerfOverlayLevel_Minimal = 4;
+}
+
+enum EGPUPerformanceLevel {
+	k_EGPUPerformanceLevel_Invalid = 0;
+	k_EGPUPerformanceLevel_Auto = 1;
+	k_EGPUPerformanceLevel_Manual = 2;
+	k_EGPUPerformanceLevel_Low = 3;
+	k_EGPUPerformanceLevel_High = 4;
+	k_EGPUPerformanceLevel_Profiling = 5;
+}
+
+enum EScalingFilter {
+	k_EScalingFilter_Invalid = 0;
+	k_EScalingFilter_FSR = 1;
+	k_EScalingFilter_Nearest = 2;
+	k_EScalingFilter_Integer = 3;
+	k_EScalingFilter_Linear = 4;
+	k_EScalingFilter_NIS = 5;
+}
+
+enum ESplitScalingFilter {
+	k_ESplitScalingFilter_Invalid = 0;
+	k_ESplitScalingFilter_Linear = 1;
+	k_ESplitScalingFilter_Nearest = 2;
+	k_ESplitScalingFilter_FSR = 3;
+	k_ESplitScalingFilter_NIS = 4;
+}
+
+enum ESplitScalingScaler {
+	k_ESplitScalingScaler_Invalid = 0;
+	k_ESplitScalingScaler_Auto = 1;
+	k_ESplitScalingScaler_Integer = 2;
+	k_ESplitScalingScaler_Fit = 3;
+	k_ESplitScalingScaler_Fill = 4;
+	k_ESplitScalingScaler_Stretch = 5;
+}
+
+enum EHDRToneMapOperator {
+	k_EHDRToneMapOperator_Invalid = 0;
+	k_EHDRToneMapOperator_Uncharted = 1;
+	k_EHDRToneMapOperator_Reinhard = 2;
+}
+
+enum ECPUGovernor {
+	k_ECPUGovernor_Invalid = 0;
+	k_ECPUGovernor_Perf = 1;
+	k_ECPUGovernor_Powersave = 2;
+	k_ECPUGovernor_Manual = 3;
+}
+
+enum EUpdaterType {
+	k_EUpdaterType_Invalid = 0;
+	k_EUpdaterType_Client = 1;
+	k_EUpdaterType_OS = 2;
+	k_EUpdaterType_BIOS = 3;
+	k_EUpdaterType_Aggregated = 4;
+	k_EUpdaterType_Test1 = 5;
+	k_EUpdaterType_Test2 = 6;
+	k_EUpdaterType_Dummy = 7;
+}
+
+enum EUpdaterState {
+	k_EUpdaterState_Invalid = 0;
+	k_EUpdaterState_UpToDate = 2;
+	k_EUpdaterState_Checking = 3;
+	k_EUpdaterState_Available = 4;
+	k_EUpdaterState_Applying = 5;
+	k_EUpdaterState_ClientRestartPending = 6;
+	k_EUpdaterState_SystemRestartPending = 7;
+}
+
+enum EStorageBlockContentType {
+	k_EStorageBlockContentType_Invalid = 0;
+	k_EStorageBlockContentType_Unknown = 1;
+	k_EStorageBlockContentType_FileSystem = 2;
+	k_EStorageBlockContentType_Crypto = 3;
+	k_EStorageBlockContentType_Raid = 4;
+}
+
+enum EStorageBlockFileSystemType {
+	k_EStorageBlockFileSystemType_Invalid = 0;
+	k_EStorageBlockFileSystemType_Unknown = 1;
+	k_EStorageBlockFileSystemType_VFat = 2;
+	k_EStorageBlockFileSystemType_Ext4 = 3;
+}
+
+enum EStorageDriveMediaType {
+	k_EStorageDriveMediaType_Invalid = 0;
+	k_EStorageDriveMediaType_Unknown = 1;
+	k_EStorageDriveMediaType_HDD = 2;
+	k_EStorageDriveMediaType_SSD = 3;
+	k_EStorageDriveMediaType_Removable = 4;
+}
+
+enum ESystemDisplayCompatibilityMode {
+	k_ESystemDisplayCompatibilityMode_Invalid = 0;
+	k_ESystemDisplayCompatibilityMode_None = 1;
+	k_ESystemDisplayCompatibilityMode_MinimalBandwith = 2;
+}
+
+enum ESteamDeckCompatibilityCategory {
+	k_ESteamDeckCompatibilityCategory_Unknown = 0;
+	k_ESteamDeckCompatibilityCategory_Unsupported = 1;
+	k_ESteamDeckCompatibilityCategory_Playable = 2;
+	k_ESteamDeckCompatibilityCategory_Verified = 3;
+}
+
+enum ESteamDeckCompatibilityResultDisplayType {
+	k_ESteamDeckCompatibilityResultDisplayType_Invisible = 0;
+	k_ESteamDeckCompatibilityResultDisplayType_Informational = 1;
+	k_ESteamDeckCompatibilityResultDisplayType_Unsupported = 2;
+	k_ESteamDeckCompatibilityResultDisplayType_Playable = 3;
+	k_ESteamDeckCompatibilityResultDisplayType_Verified = 4;
+}
+
+enum EACState {
+	k_EACState_Unknown = 0;
+	k_EACState_Disconnected = 1;
+	k_EACState_Connected = 2;
+	k_EACState_ConnectedSlow = 3;
+}
+
+enum EBatteryState {
+	k_EBatteryState_Unknown = 0;
+	k_EBatteryState_Discharging = 1;
+	k_EBatteryState_Charging = 2;
+	k_EBatteryState_Full = 3;
+}
+
+enum EOSBranch {
+	k_EOSBranch_Unknown = 0;
+	k_EOSBranch_Release = 1;
+	k_EOSBranch_ReleaseCandidate = 2;
+	k_EOSBranch_Beta = 3;
+	k_EOSBranch_BetaCandidate = 4;
+	k_EOSBranch_Main = 5;
+	k_EOSBranch_Staging = 6;
+}
+
+enum ECommunityItemClass {
+	k_ECommunityItemClass_Invalid = 0;
+	k_ECommunityItemClass_Badge = 1;
+	k_ECommunityItemClass_GameCard = 2;
+	k_ECommunityItemClass_ProfileBackground = 3;
+	k_ECommunityItemClass_Emoticon = 4;
+	k_ECommunityItemClass_BoosterPack = 5;
+	k_ECommunityItemClass_Consumable = 6;
+	k_ECommunityItemClass_GameGoo = 7;
+	k_ECommunityItemClass_ProfileModifier = 8;
+	k_ECommunityItemClass_Scene = 9;
+	k_ECommunityItemClass_SalienItem = 10;
+	k_ECommunityItemClass_Sticker = 11;
+	k_ECommunityItemClass_ChatEffect = 12;
+	k_ECommunityItemClass_MiniProfileBackground = 13;
+	k_ECommunityItemClass_AvatarFrame = 14;
+	k_ECommunityItemClass_AnimatedAvatar = 15;
+	k_ECommunityItemClass_SteamDeckKeyboardSkin = 16;
+	k_ECommunityItemClass_SteamDeckStartupMovie = 17;
+}
+
+enum ESteamDeckCompatibilityFeedback {
+	k_ESteamDeckCompatibilityFeedback_Unset = 0;
+	k_ESteamDeckCompatibilityFeedback_Agree = 1;
+	k_ESteamDeckCompatibilityFeedback_Disagree = 2;
+	k_ESteamDeckCompatibilityFeedback_Ignore = 3;
+}
+
+enum EProvideDeckFeedbackPreference {
+	k_EProvideDeckFeedbackPreference_Unset = 0;
+	k_EProvideDeckFeedbackPreference_Yes = 1;
+	k_EProvideDeckFeedbackPreference_No = 2;
+}
+
+enum ETouchGesture {
+	k_ETouchGestureNone = 0;
+	k_ETouchGestureTouch = 1;
+	k_ETouchGestureTap = 2;
+	k_ETouchGestureDoubleTap = 3;
+	k_ETouchGestureShortPress = 4;
+	k_ETouchGestureLongPress = 5;
+	k_ETouchGestureLongTap = 6;
+	k_ETouchGestureTwoFingerTap = 7;
+	k_ETouchGestureTapCancelled = 8;
+	k_ETouchGesturePinchBegin = 9;
+	k_ETouchGesturePinchUpdate = 10;
+	k_ETouchGesturePinchEnd = 11;
+	k_ETouchGestureFlingStart = 12;
+	k_ETouchGestureFlingCancelled = 13;
+}
+
+enum ESessionPersistence {
+	k_ESessionPersistence_Invalid = -1;
+	k_ESessionPersistence_Ephemeral = 0;
+	k_ESessionPersistence_Persistent = 1;
+}
+
+enum ENewSteamAnnouncementState {
+	k_ENewSteamAnnouncementState_Invalid = 0;
+	k_ENewSteamAnnouncementState_AllRead = 1;
+	k_ENewSteamAnnouncementState_NewAnnouncement = 2;
+	k_ENewSteamAnnouncementState_FeaturedAnnouncement = 3;
+}
diff --git a/protocols/Steam/src/protobuf-c/protobuf-c-util.h b/protocols/Steam/src/protobuf-c/protobuf-c-util.h
new file mode 100644
index 0000000000..09bb226aea
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/protobuf-c-util.h
@@ -0,0 +1,53 @@
+#ifndef PROTOBUF_C_UTIL_H
+#define PROTOBUF_C_UTIL_H
+
+/** \file
+ * Internal utility header file.
+ * Macros used by the generator and parser parts of the library.
+ *
+ * \author Kevin Lyda <kevin@ie.suberic.net>
+ * \date   March 2014
+ */
+
+/** \defgroup internal Internal API
+ *
+ * These are the functions and data structures used internally.  They are
+ * not exported and are not useable by users of \c libprotobuf-c-text.
+ */
+
+/* These are lifted from the protobuf-c lib */
+
+/** Used to define STRUCT_MEMBER() and STRUCT_MEMBER_PTR(). */
+#define STRUCT_MEMBER_P(struct_p, struct_offset) \
+      ((void *) ((uint8_t *) (struct_p) + (struct_offset)))
+
+/** Return a field from a message based on offset and type. */
+#define STRUCT_MEMBER(member_type, struct_p, struct_offset) \
+      (*(member_type *) STRUCT_MEMBER_P((struct_p), (struct_offset)))
+
+/** Return a pointer to a field in a message based on offset and type. */
+#define STRUCT_MEMBER_PTR(member_type, struct_p, struct_offset) \
+      ((member_type *) STRUCT_MEMBER_P((struct_p), (struct_offset)))
+
+/** Free possibly using the pbc allocator. */
+#define PBC_FREE(ptr) (allocator? allocator->free(allocator->allocator_data, \
+                                                  ptr): free(ptr))
+
+/** Allocate possibly using the pbc allocator. */
+#define PBC_ALLOC(size) (allocator? \
+                           allocator->alloc(allocator->allocator_data, size): \
+                           malloc(size))
+
+/** Free possibly using the pbc allocator (state members). */
+#define ST_FREE(ptr) (state->allocator? \
+                        state->allocator->free(state->allocator-> \
+                                               allocator_data, ptr): \
+                        free(ptr))
+
+/** Allocate possibly using the pbc allocator (state members). */
+#define ST_ALLOC(size) (state->allocator? \
+                           state->allocator->alloc(state->allocator-> \
+                                                   allocator_data, size): \
+                           malloc(size))
+
+#endif /* PROTOBUF_C_UTIL_H */
diff --git a/protocols/Steam/src/protobuf-c/protobuf-c.c b/protocols/Steam/src/protobuf-c/protobuf-c.c
new file mode 100644
index 0000000000..3001639518
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/protobuf-c.c
@@ -0,0 +1,3670 @@
+/*
+ * Copyright (c) 2008-2022, Dave Benson and the protobuf-c authors.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ * Support library for `protoc-c` generated code.
+ *
+ * This file implements the public API used by the code generated
+ * by `protoc-c`.
+ *
+ * \authors Dave Benson and the protobuf-c authors
+ *
+ * \copyright 2008-2014. Licensed under the terms of the [BSD-2-Clause] license.
+ */
+
+/**
+ * \todo 64-BIT OPTIMIZATION: certain implementations use 32-bit math
+ * even on 64-bit platforms (uint64_size, uint64_pack, parse_uint64).
+ *
+ * \todo Use size_t consistently.
+ */
+
+#include <stdlib.h>	/* for malloc, free */
+#include <string.h>	/* for strcmp, strlen, memcpy, memmove, memset */
+
+#include "protobuf-c.h"
+
+#define TRUE				1
+#define FALSE				0
+
+#define PROTOBUF_C__ASSERT_NOT_REACHED() assert(0)
+
+/* Workaround for Microsoft compilers. */
+#ifdef _MSC_VER
+# define inline __inline
+#endif
+
+/**
+ * \defgroup internal Internal functions and macros
+ *
+ * These are not exported by the library but are useful to developers working
+ * on `libprotobuf-c` itself.
+ */
+
+/**
+ * \defgroup macros Utility macros for manipulating structures
+ *
+ * Macros and constants used to manipulate the base "classes" generated by
+ * `protobuf-c`. They also define limits and check correctness.
+ *
+ * \ingroup internal
+ * @{
+ */
+
+/** The maximum length of a 64-bit integer in varint encoding. */
+#define MAX_UINT64_ENCODED_SIZE		10
+
+#ifndef PROTOBUF_C_UNPACK_ERROR
+# define PROTOBUF_C_UNPACK_ERROR(...)
+#endif
+
+#if !defined(_WIN32) || !defined(PROTOBUF_C_USE_SHARED_LIB)
+const char protobuf_c_empty_string[] = "";
+#endif
+
+/**
+ * Internal `ProtobufCMessage` manipulation macro.
+ *
+ * Base macro for manipulating a `ProtobufCMessage`. Used by STRUCT_MEMBER() and
+ * STRUCT_MEMBER_PTR().
+ */
+#define STRUCT_MEMBER_P(struct_p, struct_offset) \
+    ((void *) ((uint8_t *) (struct_p) + (struct_offset)))
+
+/**
+ * Return field in a `ProtobufCMessage` based on offset.
+ *
+ * Take a pointer to a `ProtobufCMessage` and find the field at the offset.
+ * Cast it to the passed type.
+ */
+#define STRUCT_MEMBER(member_type, struct_p, struct_offset) \
+    (*(member_type *) STRUCT_MEMBER_P((struct_p), (struct_offset)))
+
+/**
+ * Return field in a `ProtobufCMessage` based on offset.
+ *
+ * Take a pointer to a `ProtobufCMessage` and find the field at the offset. Cast
+ * it to a pointer to the passed type.
+ */
+#define STRUCT_MEMBER_PTR(member_type, struct_p, struct_offset) \
+    ((member_type *) STRUCT_MEMBER_P((struct_p), (struct_offset)))
+
+/* Assertions for magic numbers. */
+
+#define ASSERT_IS_ENUM_DESCRIPTOR(desc) \
+	assert((desc)->magic == PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC)
+
+#define ASSERT_IS_MESSAGE_DESCRIPTOR(desc) \
+	assert((desc)->magic == PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC)
+
+#define ASSERT_IS_MESSAGE(message) \
+	ASSERT_IS_MESSAGE_DESCRIPTOR((message)->descriptor)
+
+#define ASSERT_IS_SERVICE_DESCRIPTOR(desc) \
+	assert((desc)->magic == PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC)
+
+/**@}*/
+
+/* --- version --- */
+
+const char *
+protobuf_c_version(void)
+{
+	return PROTOBUF_C_VERSION;
+}
+
+uint32_t
+protobuf_c_version_number(void)
+{
+	return PROTOBUF_C_VERSION_NUMBER;
+}
+
+/* --- allocator --- */
+
+static void *
+system_alloc(void *allocator_data, size_t size)
+{
+	(void)allocator_data;
+	return malloc(size);
+}
+
+static void
+system_free(void *allocator_data, void *data)
+{
+	(void)allocator_data;
+	free(data);
+}
+
+static inline void *
+do_alloc(ProtobufCAllocator *allocator, size_t size)
+{
+	return allocator->alloc(allocator->allocator_data, size);
+}
+
+static inline void
+do_free(ProtobufCAllocator *allocator, void *data)
+{
+	if (data != NULL)
+		allocator->free(allocator->allocator_data, data);
+}
+
+/*
+ * This allocator uses the system's malloc() and free(). It is the default
+ * allocator used if NULL is passed as the ProtobufCAllocator to an exported
+ * function.
+ */
+static ProtobufCAllocator protobuf_c__allocator = {
+	.alloc = &system_alloc,
+	.free = &system_free,
+	.allocator_data = NULL,
+};
+
+/* === buffer-simple === */
+
+void
+protobuf_c_buffer_simple_append(ProtobufCBuffer *buffer,
+				size_t len, const uint8_t *data)
+{
+	ProtobufCBufferSimple *simp = (ProtobufCBufferSimple *) buffer;
+	size_t new_len = simp->len + len;
+
+	if (new_len > simp->alloced) {
+		ProtobufCAllocator *allocator = simp->allocator;
+		size_t new_alloced = simp->alloced * 2;
+		uint8_t *new_data;
+
+		if (allocator == NULL)
+			allocator = &protobuf_c__allocator;
+		while (new_alloced < new_len)
+			new_alloced += new_alloced;
+		new_data = do_alloc(allocator, new_alloced);
+		if (!new_data)
+			return;
+		memcpy(new_data, simp->data, simp->len);
+		if (simp->must_free_data)
+			do_free(allocator, simp->data);
+		else
+			simp->must_free_data = TRUE;
+		simp->data = new_data;
+		simp->alloced = new_alloced;
+	}
+	memcpy(simp->data + simp->len, data, len);
+	simp->len = new_len;
+}
+
+/**
+ * \defgroup packedsz protobuf_c_message_get_packed_size() implementation
+ *
+ * Routines mainly used by protobuf_c_message_get_packed_size().
+ *
+ * \ingroup internal
+ * @{
+ */
+
+/**
+ * Return the number of bytes required to store the tag for the field. Includes
+ * 3 bits for the wire-type, and a single bit that denotes the end-of-tag.
+ *
+ * \param number
+ *      Field tag to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static inline size_t
+get_tag_size(uint32_t number)
+{
+	if (number < (1UL << 4)) {
+		return 1;
+	} else if (number < (1UL << 11)) {
+		return 2;
+	} else if (number < (1UL << 18)) {
+		return 3;
+	} else if (number < (1UL << 25)) {
+		return 4;
+	} else {
+		return 5;
+	}
+}
+
+/**
+ * Return the number of bytes required to store a variable-length unsigned
+ * 32-bit integer in base-128 varint encoding.
+ *
+ * \param v
+ *      Value to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static inline size_t
+uint32_size(uint32_t v)
+{
+	if (v < (1UL << 7)) {
+		return 1;
+	} else if (v < (1UL << 14)) {
+		return 2;
+	} else if (v < (1UL << 21)) {
+		return 3;
+	} else if (v < (1UL << 28)) {
+		return 4;
+	} else {
+		return 5;
+	}
+}
+
+/**
+ * Return the number of bytes required to store a variable-length signed 32-bit
+ * integer in base-128 varint encoding.
+ *
+ * \param v
+ *      Value to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static inline size_t
+int32_size(int32_t v)
+{
+	if (v < 0) {
+		return 10;
+	} else if (v < (1L << 7)) {
+		return 1;
+	} else if (v < (1L << 14)) {
+		return 2;
+	} else if (v < (1L << 21)) {
+		return 3;
+	} else if (v < (1L << 28)) {
+		return 4;
+	} else {
+		return 5;
+	}
+}
+
+/**
+ * Return the ZigZag-encoded 32-bit unsigned integer form of a 32-bit signed
+ * integer.
+ *
+ * \param v
+ *      Value to encode.
+ * \return
+ *      ZigZag encoded integer.
+ */
+static inline uint32_t
+zigzag32(int32_t v)
+{
+	// Note:  Using unsigned types prevents undefined behavior
+	return ((uint32_t)v << 1) ^ -((uint32_t)v >> 31);
+}
+
+/**
+ * Return the number of bytes required to store a signed 32-bit integer,
+ * converted to an unsigned 32-bit integer with ZigZag encoding, using base-128
+ * varint encoding.
+ *
+ * \param v
+ *      Value to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static inline size_t
+sint32_size(int32_t v)
+{
+	return uint32_size(zigzag32(v));
+}
+
+/**
+ * Return the number of bytes required to store a 64-bit unsigned integer in
+ * base-128 varint encoding.
+ *
+ * \param v
+ *      Value to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static inline size_t
+uint64_size(uint64_t v)
+{
+	uint32_t upper_v = (uint32_t) (v >> 32);
+
+	if (upper_v == 0) {
+		return uint32_size((uint32_t) v);
+	} else if (upper_v < (1UL << 3)) {
+		return 5;
+	} else if (upper_v < (1UL << 10)) {
+		return 6;
+	} else if (upper_v < (1UL << 17)) {
+		return 7;
+	} else if (upper_v < (1UL << 24)) {
+		return 8;
+	} else if (upper_v < (1UL << 31)) {
+		return 9;
+	} else {
+		return 10;
+	}
+}
+
+/**
+ * Return the ZigZag-encoded 64-bit unsigned integer form of a 64-bit signed
+ * integer.
+ *
+ * \param v
+ *      Value to encode.
+ * \return
+ *      ZigZag encoded integer.
+ */
+static inline uint64_t
+zigzag64(int64_t v)
+{
+	// Note:  Using unsigned types prevents undefined behavior
+	return ((uint64_t)v << 1) ^ -((uint64_t)v >> 63);
+}
+
+/**
+ * Return the number of bytes required to store a signed 64-bit integer,
+ * converted to an unsigned 64-bit integer with ZigZag encoding, using base-128
+ * varint encoding.
+ *
+ * \param v
+ *      Value to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static inline size_t
+sint64_size(int64_t v)
+{
+	return uint64_size(zigzag64(v));
+}
+
+/**
+ * Calculate the serialized size of a single required message field, including
+ * the space needed by the preceding tag.
+ *
+ * \param field
+ *      Field descriptor for member.
+ * \param member
+ *      Field to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static size_t
+required_field_get_packed_size(const ProtobufCFieldDescriptor *field,
+			       const void *member)
+{
+	size_t rv = get_tag_size(field->id);
+
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_SINT32:
+		return rv + sint32_size(*(const int32_t *) member);
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+		return rv + int32_size(*(const int32_t *) member);
+	case PROTOBUF_C_TYPE_UINT32:
+		return rv + uint32_size(*(const uint32_t *) member);
+	case PROTOBUF_C_TYPE_SINT64:
+		return rv + sint64_size(*(const int64_t *) member);
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		return rv + uint64_size(*(const uint64_t *) member);
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+		return rv + 4;
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+		return rv + 8;
+	case PROTOBUF_C_TYPE_BOOL:
+		return rv + 1;
+	case PROTOBUF_C_TYPE_FLOAT:
+		return rv + 4;
+	case PROTOBUF_C_TYPE_DOUBLE:
+		return rv + 8;
+	case PROTOBUF_C_TYPE_STRING: {
+		const char *str = *(char * const *) member;
+		size_t len = str ? strlen(str) : 0;
+		return rv + uint32_size(len) + len;
+	}
+	case PROTOBUF_C_TYPE_BYTES: {
+		size_t len = ((const ProtobufCBinaryData *) member)->len;
+		return rv + uint32_size(len) + len;
+	}
+	case PROTOBUF_C_TYPE_MESSAGE: {
+		const ProtobufCMessage *msg = *(ProtobufCMessage * const *) member;
+		size_t subrv = msg ? protobuf_c_message_get_packed_size(msg) : 0;
+		return rv + uint32_size(subrv) + subrv;
+	}
+	}
+	PROTOBUF_C__ASSERT_NOT_REACHED();
+	return 0;
+}
+
+/**
+ * Calculate the serialized size of a single oneof message field, including
+ * the space needed by the preceding tag. Returns 0 if the oneof field isn't
+ * selected or is not set.
+ *
+ * \param field
+ *      Field descriptor for member.
+ * \param oneof_case
+ *      Enum value that selects the field in the oneof.
+ * \param member
+ *      Field to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static size_t
+oneof_field_get_packed_size(const ProtobufCFieldDescriptor *field,
+			    uint32_t oneof_case,
+			    const void *member)
+{
+	if (oneof_case != field->id) {
+		return 0;
+	}
+	if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
+	    field->type == PROTOBUF_C_TYPE_STRING)
+	{
+		const void *ptr = *(const void * const *) member;
+		if (ptr == NULL || ptr == field->default_value)
+			return 0;
+	}
+	return required_field_get_packed_size(field, member);
+}
+
+/**
+ * Calculate the serialized size of a single optional message field, including
+ * the space needed by the preceding tag. Returns 0 if the optional field isn't
+ * set.
+ *
+ * \param field
+ *      Field descriptor for member.
+ * \param has
+ *      True if the field exists, false if not.
+ * \param member
+ *      Field to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static size_t
+optional_field_get_packed_size(const ProtobufCFieldDescriptor *field,
+			       const protobuf_c_boolean has,
+			       const void *member)
+{
+	if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
+	    field->type == PROTOBUF_C_TYPE_STRING)
+	{
+		const void *ptr = *(const void * const *) member;
+		if (ptr == NULL || ptr == field->default_value)
+			return 0;
+	} else {
+		if (!has)
+			return 0;
+	}
+	return required_field_get_packed_size(field, member);
+}
+
+static protobuf_c_boolean
+field_is_zeroish(const ProtobufCFieldDescriptor *field,
+		 const void *member)
+{
+	protobuf_c_boolean ret = FALSE;
+
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_BOOL:
+		ret = (0 == *(const protobuf_c_boolean *) member);
+		break;
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_SINT32:
+	case PROTOBUF_C_TYPE_INT32:
+	case PROTOBUF_C_TYPE_UINT32:
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+		ret = (0 == *(const uint32_t *) member);
+		break;
+	case PROTOBUF_C_TYPE_SINT64:
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+		ret = (0 == *(const uint64_t *) member);
+		break;
+	case PROTOBUF_C_TYPE_FLOAT:
+		ret = (0 == *(const float *) member);
+		break;
+	case PROTOBUF_C_TYPE_DOUBLE:
+		ret = (0 == *(const double *) member);
+		break;
+	case PROTOBUF_C_TYPE_STRING:
+		ret = (NULL == *(const char * const *) member) ||
+		      ('\0' == **(const char * const *) member);
+		break;
+	case PROTOBUF_C_TYPE_BYTES:
+	case PROTOBUF_C_TYPE_MESSAGE:
+		ret = (NULL == *(const void * const *) member);
+		break;
+	default:
+		ret = TRUE;
+		break;
+	}
+
+	return ret;
+}
+
+/**
+ * Calculate the serialized size of a single unlabeled message field, including
+ * the space needed by the preceding tag. Returns 0 if the field isn't set or
+ * if it is set to a "zeroish" value (null pointer or 0 for numerical values).
+ * Unlabeled fields are supported only in proto3.
+ *
+ * \param field
+ *      Field descriptor for member.
+ * \param member
+ *      Field to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static size_t
+unlabeled_field_get_packed_size(const ProtobufCFieldDescriptor *field,
+				const void *member)
+{
+	if (field_is_zeroish(field, member))
+		return 0;
+	return required_field_get_packed_size(field, member);
+}
+
+/**
+ * Calculate the serialized size of repeated message fields, which may consist
+ * of any number of values (including 0). Includes the space needed by the
+ * preceding tags (as needed).
+ *
+ * \param field
+ *      Field descriptor for member.
+ * \param count
+ *      Number of repeated field members.
+ * \param member
+ *      Field to encode.
+ * \return
+ *      Number of bytes required.
+ */
+static size_t
+repeated_field_get_packed_size(const ProtobufCFieldDescriptor *field,
+			       size_t count, const void *member)
+{
+	size_t header_size;
+	size_t rv = 0;
+	unsigned i;
+	void *array = *(void * const *) member;
+
+	if (count == 0)
+		return 0;
+	header_size = get_tag_size(field->id);
+	if (0 == (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED))
+		header_size *= count;
+
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_SINT32:
+		for (i = 0; i < count; i++)
+			rv += sint32_size(((int32_t *) array)[i]);
+		break;
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+		for (i = 0; i < count; i++)
+			rv += int32_size(((int32_t *) array)[i]);
+		break;
+	case PROTOBUF_C_TYPE_UINT32:
+		for (i = 0; i < count; i++)
+			rv += uint32_size(((uint32_t *) array)[i]);
+		break;
+	case PROTOBUF_C_TYPE_SINT64:
+		for (i = 0; i < count; i++)
+			rv += sint64_size(((int64_t *) array)[i]);
+		break;
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		for (i = 0; i < count; i++)
+			rv += uint64_size(((uint64_t *) array)[i]);
+		break;
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+		rv += 4 * count;
+		break;
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		rv += 8 * count;
+		break;
+	case PROTOBUF_C_TYPE_BOOL:
+		rv += count;
+		break;
+	case PROTOBUF_C_TYPE_STRING:
+		for (i = 0; i < count; i++) {
+			size_t len = strlen(((char **) array)[i]);
+			rv += uint32_size(len) + len;
+		}
+		break;
+	case PROTOBUF_C_TYPE_BYTES:
+		for (i = 0; i < count; i++) {
+			size_t len = ((ProtobufCBinaryData *) array)[i].len;
+			rv += uint32_size(len) + len;
+		}
+		break;
+	case PROTOBUF_C_TYPE_MESSAGE:
+		for (i = 0; i < count; i++) {
+			size_t len = protobuf_c_message_get_packed_size(
+				((ProtobufCMessage **) array)[i]);
+			rv += uint32_size(len) + len;
+		}
+		break;
+	}
+
+	if (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED))
+		header_size += uint32_size(rv);
+	return header_size + rv;
+}
+
+/**
+ * Calculate the serialized size of an unknown field, i.e. one that is passed
+ * through mostly uninterpreted. This is required for forward compatibility if
+ * new fields are added to the message descriptor.
+ *
+ * \param field
+ *      Unknown field type.
+ * \return
+ *      Number of bytes required.
+ */
+static inline size_t
+unknown_field_get_packed_size(const ProtobufCMessageUnknownField *field)
+{
+	return get_tag_size(field->tag) + field->len;
+}
+
+/**@}*/
+
+/*
+ * Calculate the serialized size of the message.
+ */
+size_t protobuf_c_message_get_packed_size(const ProtobufCMessage *message)
+{
+	unsigned i;
+	size_t rv = 0;
+
+	ASSERT_IS_MESSAGE(message);
+	for (i = 0; i < message->descriptor->n_fields; i++) {
+		const ProtobufCFieldDescriptor *field =
+			message->descriptor->fields + i;
+		const void *member =
+			((const char *) message) + field->offset;
+		const void *qmember =
+			((const char *) message) + field->quantifier_offset;
+
+		if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
+			rv += required_field_get_packed_size(field, member);
+		} else if ((field->label == PROTOBUF_C_LABEL_OPTIONAL ||
+			    field->label == PROTOBUF_C_LABEL_NONE) &&
+			   (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_ONEOF))) {
+			rv += oneof_field_get_packed_size(
+				field,
+				*(const uint32_t *) qmember,
+				member
+			);
+		} else if (field->label == PROTOBUF_C_LABEL_OPTIONAL) {
+			rv += optional_field_get_packed_size(
+				field,
+				*(protobuf_c_boolean *) qmember,
+				member
+			);
+		} else if (field->label == PROTOBUF_C_LABEL_NONE) {
+			rv += unlabeled_field_get_packed_size(
+				field,
+				member
+			);
+		} else {
+			rv += repeated_field_get_packed_size(
+				field,
+				*(const size_t *) qmember,
+				member
+			);
+		}
+	}
+	for (i = 0; i < message->n_unknown_fields; i++)
+		rv += unknown_field_get_packed_size(&message->unknown_fields[i]);
+	return rv;
+}
+
+/**
+ * \defgroup pack protobuf_c_message_pack() implementation
+ *
+ * Routines mainly used by protobuf_c_message_pack().
+ *
+ * \ingroup internal
+ * @{
+ */
+
+/**
+ * Pack an unsigned 32-bit integer in base-128 varint encoding and return the
+ * number of bytes written, which must be 5 or less.
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+uint32_pack(uint32_t value, uint8_t *out)
+{
+	unsigned rv = 0;
+
+	if (value >= 0x80) {
+		out[rv++] = value | 0x80;
+		value >>= 7;
+		if (value >= 0x80) {
+			out[rv++] = value | 0x80;
+			value >>= 7;
+			if (value >= 0x80) {
+				out[rv++] = value | 0x80;
+				value >>= 7;
+				if (value >= 0x80) {
+					out[rv++] = value | 0x80;
+					value >>= 7;
+				}
+			}
+		}
+	}
+	/* assert: value<128 */
+	out[rv++] = value;
+	return rv;
+}
+
+/**
+ * Pack a signed 32-bit integer and return the number of bytes written,
+ * passed as unsigned to avoid implementation-specific behavior.
+ * Negative numbers are encoded as two's complement 64-bit integers.
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+int32_pack(uint32_t value, uint8_t *out)
+{
+	if ((int32_t)value < 0) {
+		out[0] = value | 0x80;
+		out[1] = (value >> 7) | 0x80;
+		out[2] = (value >> 14) | 0x80;
+		out[3] = (value >> 21) | 0x80;
+		out[4] = (value >> 28) | 0xf0;
+		out[5] = out[6] = out[7] = out[8] = 0xff;
+		out[9] = 0x01;
+		return 10;
+	} else {
+		return uint32_pack(value, out);
+	}
+}
+
+/**
+ * Pack a signed 32-bit integer using ZigZag encoding and return the number of
+ * bytes written.
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+sint32_pack(int32_t value, uint8_t *out)
+{
+	return uint32_pack(zigzag32(value), out);
+}
+
+/**
+ * Pack a 64-bit unsigned integer using base-128 varint encoding and return the
+ * number of bytes written.
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static size_t
+uint64_pack(uint64_t value, uint8_t *out)
+{
+	uint32_t hi = (uint32_t) (value >> 32);
+	uint32_t lo = (uint32_t) value;
+	unsigned rv;
+
+	if (hi == 0)
+		return uint32_pack((uint32_t) lo, out);
+	out[0] = (lo) | 0x80;
+	out[1] = (lo >> 7) | 0x80;
+	out[2] = (lo >> 14) | 0x80;
+	out[3] = (lo >> 21) | 0x80;
+	if (hi < 8) {
+		out[4] = (hi << 4) | (lo >> 28);
+		return 5;
+	} else {
+		out[4] = ((hi & 7) << 4) | (lo >> 28) | 0x80;
+		hi >>= 3;
+	}
+	rv = 5;
+	while (hi >= 128) {
+		out[rv++] = hi | 0x80;
+		hi >>= 7;
+	}
+	out[rv++] = hi;
+	return rv;
+}
+
+/**
+ * Pack a 64-bit signed integer in ZigZag encoding and return the number of
+ * bytes written.
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+sint64_pack(int64_t value, uint8_t *out)
+{
+	return uint64_pack(zigzag64(value), out);
+}
+
+/**
+ * Pack a 32-bit quantity in little-endian byte order. Used for protobuf wire
+ * types fixed32, sfixed32, float. Similar to "htole32".
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+fixed32_pack(uint32_t value, void *out)
+{
+#if !defined(WORDS_BIGENDIAN)
+	memcpy(out, &value, 4);
+#else
+	uint8_t *buf = out;
+
+	buf[0] = value;
+	buf[1] = value >> 8;
+	buf[2] = value >> 16;
+	buf[3] = value >> 24;
+#endif
+	return 4;
+}
+
+/**
+ * Pack a 64-bit quantity in little-endian byte order. Used for protobuf wire
+ * types fixed64, sfixed64, double. Similar to "htole64".
+ *
+ * \todo The big-endian impl is really only good for 32-bit machines, a 64-bit
+ * version would be appreciated, plus a way to decide to use 64-bit math where
+ * convenient.
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+fixed64_pack(uint64_t value, void *out)
+{
+#if !defined(WORDS_BIGENDIAN)
+	memcpy(out, &value, 8);
+#else
+	fixed32_pack(value, out);
+	fixed32_pack(value >> 32, ((char *) out) + 4);
+#endif
+	return 8;
+}
+
+/**
+ * Pack a boolean value as an integer and return the number of bytes written.
+ *
+ * \todo Perhaps on some platforms *out = !!value would be a better impl, b/c
+ * that is idiomatic C++ in some STL implementations.
+ *
+ * \param value
+ *      Value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+boolean_pack(protobuf_c_boolean value, uint8_t *out)
+{
+	*out = value ? TRUE : FALSE;
+	return 1;
+}
+
+/**
+ * Pack a NUL-terminated C string and return the number of bytes written. The
+ * output includes a length delimiter.
+ *
+ * The NULL pointer is treated as an empty string. This isn't really necessary,
+ * but it allows people to leave required strings blank. (See Issue #13 in the
+ * bug tracker for a little more explanation).
+ *
+ * \param str
+ *      String to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+string_pack(const char *str, uint8_t *out)
+{
+	if (str == NULL) {
+		out[0] = 0;
+		return 1;
+	} else {
+		size_t len = strlen(str);
+		size_t rv = uint32_pack(len, out);
+		memcpy(out + rv, str, len);
+		return rv + len;
+	}
+}
+
+/**
+ * Pack a ProtobufCBinaryData and return the number of bytes written. The output
+ * includes a length delimiter.
+ *
+ * \param bd
+ *      ProtobufCBinaryData to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+binary_data_pack(const ProtobufCBinaryData *bd, uint8_t *out)
+{
+	size_t len = bd->len;
+	size_t rv = uint32_pack(len, out);
+	memcpy(out + rv, bd->data, len);
+	return rv + len;
+}
+
+/**
+ * Pack a ProtobufCMessage and return the number of bytes written. The output
+ * includes a length delimiter.
+ *
+ * \param message
+ *      ProtobufCMessage object to pack.
+ * \param[out] out
+ *      Packed message.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static inline size_t
+prefixed_message_pack(const ProtobufCMessage *message, uint8_t *out)
+{
+	if (message == NULL) {
+		out[0] = 0;
+		return 1;
+	} else {
+		size_t rv = protobuf_c_message_pack(message, out + 1);
+		uint32_t rv_packed_size = uint32_size(rv);
+		if (rv_packed_size != 1)
+			memmove(out + rv_packed_size, out + 1, rv);
+		return uint32_pack(rv, out) + rv;
+	}
+}
+
+/**
+ * Pack a field tag.
+ *
+ * Wire-type will be added in required_field_pack().
+ *
+ * \todo Just call uint64_pack on 64-bit platforms.
+ *
+ * \param id
+ *      Tag value to encode.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static size_t
+tag_pack(uint32_t id, uint8_t *out)
+{
+	if (id < (1UL << (32 - 3)))
+		return uint32_pack(id << 3, out);
+	else
+		return uint64_pack(((uint64_t) id) << 3, out);
+}
+
+/**
+ * Pack a required field and return the number of bytes written.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param member
+ *      The field member.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static size_t
+required_field_pack(const ProtobufCFieldDescriptor *field,
+		    const void *member, uint8_t *out)
+{
+	size_t rv = tag_pack(field->id, out);
+
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_SINT32:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		return rv + sint32_pack(*(const int32_t *) member, out + rv);
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		return rv + int32_pack(*(const int32_t *) member, out + rv);
+	case PROTOBUF_C_TYPE_UINT32:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		return rv + uint32_pack(*(const uint32_t *) member, out + rv);
+	case PROTOBUF_C_TYPE_SINT64:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		return rv + sint64_pack(*(const int64_t *) member, out + rv);
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		return rv + uint64_pack(*(const uint64_t *) member, out + rv);
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_32BIT;
+		return rv + fixed32_pack(*(const uint32_t *) member, out + rv);
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_64BIT;
+		return rv + fixed64_pack(*(const uint64_t *) member, out + rv);
+	case PROTOBUF_C_TYPE_BOOL:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		return rv + boolean_pack(*(const protobuf_c_boolean *) member, out + rv);
+	case PROTOBUF_C_TYPE_STRING:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		return rv + string_pack(*(char *const *) member, out + rv);
+	case PROTOBUF_C_TYPE_BYTES:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		return rv + binary_data_pack((const ProtobufCBinaryData *) member, out + rv);
+	case PROTOBUF_C_TYPE_MESSAGE:
+		out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		return rv + prefixed_message_pack(*(ProtobufCMessage * const *) member, out + rv);
+	}
+	PROTOBUF_C__ASSERT_NOT_REACHED();
+	return 0;
+}
+
+/**
+ * Pack a oneof field and return the number of bytes written. Only packs the
+ * field that is selected by the case enum.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param oneof_case
+ *      Enum value that selects the field in the oneof.
+ * \param member
+ *      The field member.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static size_t
+oneof_field_pack(const ProtobufCFieldDescriptor *field,
+		 uint32_t oneof_case,
+		 const void *member, uint8_t *out)
+{
+	if (oneof_case != field->id) {
+		return 0;
+	}
+	if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
+	    field->type == PROTOBUF_C_TYPE_STRING)
+	{
+		const void *ptr = *(const void * const *) member;
+		if (ptr == NULL || ptr == field->default_value)
+			return 0;
+	}
+	return required_field_pack(field, member, out);
+}
+
+/**
+ * Pack an optional field and return the number of bytes written.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param has
+ *      Whether the field is set.
+ * \param member
+ *      The field member.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static size_t
+optional_field_pack(const ProtobufCFieldDescriptor *field,
+		    const protobuf_c_boolean has,
+		    const void *member, uint8_t *out)
+{
+	if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
+	    field->type == PROTOBUF_C_TYPE_STRING)
+	{
+		const void *ptr = *(const void * const *) member;
+		if (ptr == NULL || ptr == field->default_value)
+			return 0;
+	} else {
+		if (!has)
+			return 0;
+	}
+	return required_field_pack(field, member, out);
+}
+
+/**
+ * Pack an unlabeled field and return the number of bytes written.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param member
+ *      The field member.
+ * \param[out] out
+ *      Packed value.
+ * \return
+ *      Number of bytes written to `out`.
+ */
+static size_t
+unlabeled_field_pack(const ProtobufCFieldDescriptor *field,
+		     const void *member, uint8_t *out)
+{
+	if (field_is_zeroish(field, member))
+		return 0;
+	return required_field_pack(field, member, out);
+}
+
+/**
+ * Given a field type, return the in-memory size.
+ *
+ * \todo Implement as a table lookup.
+ *
+ * \param type
+ *      Field type.
+ * \return
+ *      Size of the field.
+ */
+static inline size_t
+sizeof_elt_in_repeated_array(ProtobufCType type)
+{
+	switch (type) {
+	case PROTOBUF_C_TYPE_SINT32:
+	case PROTOBUF_C_TYPE_INT32:
+	case PROTOBUF_C_TYPE_UINT32:
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+	case PROTOBUF_C_TYPE_ENUM:
+		return 4;
+	case PROTOBUF_C_TYPE_SINT64:
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		return 8;
+	case PROTOBUF_C_TYPE_BOOL:
+		return sizeof(protobuf_c_boolean);
+	case PROTOBUF_C_TYPE_STRING:
+	case PROTOBUF_C_TYPE_MESSAGE:
+		return sizeof(void *);
+	case PROTOBUF_C_TYPE_BYTES:
+		return sizeof(ProtobufCBinaryData);
+	}
+	PROTOBUF_C__ASSERT_NOT_REACHED();
+	return 0;
+}
+
+/**
+ * Pack an array of 32-bit quantities.
+ *
+ * \param[out] out
+ *      Destination.
+ * \param[in] in
+ *      Source.
+ * \param[in] n
+ *      Number of elements in the source array.
+ */
+static void
+copy_to_little_endian_32(void *out, const void *in, const unsigned n)
+{
+#if !defined(WORDS_BIGENDIAN)
+	memcpy(out, in, n * 4);
+#else
+	unsigned i;
+	const uint32_t *ini = in;
+	for (i = 0; i < n; i++)
+		fixed32_pack(ini[i], (uint32_t *) out + i);
+#endif
+}
+
+/**
+ * Pack an array of 64-bit quantities.
+ *
+ * \param[out] out
+ *      Destination.
+ * \param[in] in
+ *      Source.
+ * \param[in] n
+ *      Number of elements in the source array.
+ */
+static void
+copy_to_little_endian_64(void *out, const void *in, const unsigned n)
+{
+#if !defined(WORDS_BIGENDIAN)
+	memcpy(out, in, n * 8);
+#else
+	unsigned i;
+	const uint64_t *ini = in;
+	for (i = 0; i < n; i++)
+		fixed64_pack(ini[i], (uint64_t *) out + i);
+#endif
+}
+
+/**
+ * Get the minimum number of bytes required to pack a field value of a
+ * particular type.
+ *
+ * \param type
+ *      Field type.
+ * \return
+ *      Number of bytes.
+ */
+static unsigned
+get_type_min_size(ProtobufCType type)
+{
+	if (type == PROTOBUF_C_TYPE_SFIXED32 ||
+	    type == PROTOBUF_C_TYPE_FIXED32 ||
+	    type == PROTOBUF_C_TYPE_FLOAT)
+	{
+		return 4;
+	}
+	if (type == PROTOBUF_C_TYPE_SFIXED64 ||
+	    type == PROTOBUF_C_TYPE_FIXED64 ||
+	    type == PROTOBUF_C_TYPE_DOUBLE)
+	{
+		return 8;
+	}
+	return 1;
+}
+
+/**
+ * Packs the elements of a repeated field and returns the serialised field and
+ * its length.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param count
+ *      Number of elements in the repeated field array.
+ * \param member
+ *      Pointer to the elements for this repeated field.
+ * \param[out] out
+ *      Serialised representation of the repeated field.
+ * \return
+ *      Number of bytes serialised to `out`.
+ */
+static size_t
+repeated_field_pack(const ProtobufCFieldDescriptor *field,
+		    size_t count, const void *member, uint8_t *out)
+{
+	void *array = *(void * const *) member;
+	unsigned i;
+
+	if (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED)) {
+		unsigned header_len;
+		unsigned len_start;
+		unsigned min_length;
+		unsigned payload_len;
+		unsigned length_size_min;
+		unsigned actual_length_size;
+		uint8_t *payload_at;
+
+		if (count == 0)
+			return 0;
+		header_len = tag_pack(field->id, out);
+		out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		len_start = header_len;
+		min_length = get_type_min_size(field->type) * count;
+		length_size_min = uint32_size(min_length);
+		header_len += length_size_min;
+		payload_at = out + header_len;
+
+		switch (field->type) {
+		case PROTOBUF_C_TYPE_SFIXED32:
+		case PROTOBUF_C_TYPE_FIXED32:
+		case PROTOBUF_C_TYPE_FLOAT:
+			copy_to_little_endian_32(payload_at, array, count);
+			payload_at += count * 4;
+			break;
+		case PROTOBUF_C_TYPE_SFIXED64:
+		case PROTOBUF_C_TYPE_FIXED64:
+		case PROTOBUF_C_TYPE_DOUBLE:
+			copy_to_little_endian_64(payload_at, array, count);
+			payload_at += count * 8;
+			break;
+		case PROTOBUF_C_TYPE_ENUM:
+		case PROTOBUF_C_TYPE_INT32: {
+			const int32_t *arr = (const int32_t *) array;
+			for (i = 0; i < count; i++)
+				payload_at += int32_pack(arr[i], payload_at);
+			break;
+		}
+		case PROTOBUF_C_TYPE_SINT32: {
+			const int32_t *arr = (const int32_t *) array;
+			for (i = 0; i < count; i++)
+				payload_at += sint32_pack(arr[i], payload_at);
+			break;
+		}
+		case PROTOBUF_C_TYPE_SINT64: {
+			const int64_t *arr = (const int64_t *) array;
+			for (i = 0; i < count; i++)
+				payload_at += sint64_pack(arr[i], payload_at);
+			break;
+		}
+		case PROTOBUF_C_TYPE_UINT32: {
+			const uint32_t *arr = (const uint32_t *) array;
+			for (i = 0; i < count; i++)
+				payload_at += uint32_pack(arr[i], payload_at);
+			break;
+		}
+		case PROTOBUF_C_TYPE_INT64:
+		case PROTOBUF_C_TYPE_UINT64: {
+			const uint64_t *arr = (const uint64_t *) array;
+			for (i = 0; i < count; i++)
+				payload_at += uint64_pack(arr[i], payload_at);
+			break;
+		}
+		case PROTOBUF_C_TYPE_BOOL: {
+			const protobuf_c_boolean *arr = (const protobuf_c_boolean *) array;
+			for (i = 0; i < count; i++)
+				payload_at += boolean_pack(arr[i], payload_at);
+			break;
+		}
+		default:
+			PROTOBUF_C__ASSERT_NOT_REACHED();
+		}
+
+		payload_len = payload_at - (out + header_len);
+		actual_length_size = uint32_size(payload_len);
+		if (length_size_min != actual_length_size) {
+			assert(actual_length_size == length_size_min + 1);
+			memmove(out + header_len + 1, out + header_len,
+				payload_len);
+			header_len++;
+		}
+		uint32_pack(payload_len, out + len_start);
+		return header_len + payload_len;
+	} else {
+		/* not "packed" cased */
+		/* CONSIDER: optimize this case a bit (by putting the loop inside the switch) */
+		size_t rv = 0;
+		unsigned siz = sizeof_elt_in_repeated_array(field->type);
+
+		for (i = 0; i < count; i++) {
+			rv += required_field_pack(field, array, out + rv);
+			array = (char *)array + siz;
+		}
+		return rv;
+	}
+}
+
+static size_t
+unknown_field_pack(const ProtobufCMessageUnknownField *field, uint8_t *out)
+{
+	size_t rv = tag_pack(field->tag, out);
+	out[0] |= field->wire_type;
+	memcpy(out + rv, field->data, field->len);
+	return rv + field->len;
+}
+
+/**@}*/
+
+size_t
+protobuf_c_message_pack(const ProtobufCMessage *message, uint8_t *out)
+{
+	unsigned i;
+	size_t rv = 0;
+
+	ASSERT_IS_MESSAGE(message);
+	for (i = 0; i < message->descriptor->n_fields; i++) {
+		const ProtobufCFieldDescriptor *field =
+			message->descriptor->fields + i;
+		const void *member = ((const char *) message) + field->offset;
+
+		/*
+		 * It doesn't hurt to compute qmember (a pointer to the
+		 * quantifier field of the structure), but the pointer is only
+		 * valid if the field is:
+		 *  - a repeated field, or
+		 *  - a field that is part of a oneof
+		 *  - an optional field that isn't a pointer type
+		 * (Meaning: not a message or a string).
+		 */
+		const void *qmember =
+			((const char *) message) + field->quantifier_offset;
+
+		if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
+			rv += required_field_pack(field, member, out + rv);
+		} else if ((field->label == PROTOBUF_C_LABEL_OPTIONAL ||
+			    field->label == PROTOBUF_C_LABEL_NONE) &&
+			   (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_ONEOF))) {
+			rv += oneof_field_pack(
+				field,
+				*(const uint32_t *) qmember,
+				member,
+				out + rv
+			);
+		} else if (field->label == PROTOBUF_C_LABEL_OPTIONAL) {
+			rv += optional_field_pack(
+				field,
+				*(const protobuf_c_boolean *) qmember,
+				member,
+				out + rv
+			);
+		} else if (field->label == PROTOBUF_C_LABEL_NONE) {
+			rv += unlabeled_field_pack(field, member, out + rv);
+		} else {
+			rv += repeated_field_pack(field, *(const size_t *) qmember,
+				member, out + rv);
+		}
+	}
+	for (i = 0; i < message->n_unknown_fields; i++)
+		rv += unknown_field_pack(&message->unknown_fields[i], out + rv);
+	return rv;
+}
+
+/**
+ * \defgroup packbuf protobuf_c_message_pack_to_buffer() implementation
+ *
+ * Routines mainly used by protobuf_c_message_pack_to_buffer().
+ *
+ * \ingroup internal
+ * @{
+ */
+
+/**
+ * Pack a required field to a virtual buffer.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param member
+ *      The element to be packed.
+ * \param[out] buffer
+ *      Virtual buffer to append data to.
+ * \return
+ *      Number of bytes packed.
+ */
+static size_t
+required_field_pack_to_buffer(const ProtobufCFieldDescriptor *field,
+			      const void *member, ProtobufCBuffer *buffer)
+{
+	size_t rv;
+	uint8_t scratch[MAX_UINT64_ENCODED_SIZE * 2];
+
+	rv = tag_pack(field->id, scratch);
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_SINT32:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		rv += sint32_pack(*(const int32_t *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		rv += int32_pack(*(const int32_t *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_UINT32:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		rv += uint32_pack(*(const uint32_t *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_SINT64:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		rv += sint64_pack(*(const int64_t *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		rv += uint64_pack(*(const uint64_t *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_32BIT;
+		rv += fixed32_pack(*(const uint32_t *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_64BIT;
+		rv += fixed64_pack(*(const uint64_t *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_BOOL:
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
+		rv += boolean_pack(*(const protobuf_c_boolean *) member, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		break;
+	case PROTOBUF_C_TYPE_STRING: {
+		const char *str = *(char *const *) member;
+		size_t sublen = str ? strlen(str) : 0;
+
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		rv += uint32_pack(sublen, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		buffer->append(buffer, sublen, (const uint8_t *) str);
+		rv += sublen;
+		break;
+	}
+	case PROTOBUF_C_TYPE_BYTES: {
+		const ProtobufCBinaryData *bd = ((const ProtobufCBinaryData *) member);
+		size_t sublen = bd->len;
+
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		rv += uint32_pack(sublen, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		buffer->append(buffer, sublen, bd->data);
+		rv += sublen;
+		break;
+	}
+	case PROTOBUF_C_TYPE_MESSAGE: {
+		const ProtobufCMessage *msg = *(ProtobufCMessage * const *) member;
+		
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		if (msg == NULL) {
+			rv += uint32_pack(0, scratch + rv);
+			buffer->append(buffer, rv, scratch);
+		} else {
+			size_t sublen = protobuf_c_message_get_packed_size(msg);
+			rv += uint32_pack(sublen, scratch + rv);
+			buffer->append(buffer, rv, scratch);
+			protobuf_c_message_pack_to_buffer(msg, buffer);
+			rv += sublen;
+		}
+		break;
+	}
+	default:
+		PROTOBUF_C__ASSERT_NOT_REACHED();
+	}
+	return rv;
+}
+
+/**
+ * Pack a oneof field to a buffer. Only packs the field that is selected by the case enum.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param oneof_case
+ *      Enum value that selects the field in the oneof.
+ * \param member
+ *      The element to be packed.
+ * \param[out] buffer
+ *      Virtual buffer to append data to.
+ * \return
+ *      Number of bytes serialised to `buffer`.
+ */
+static size_t
+oneof_field_pack_to_buffer(const ProtobufCFieldDescriptor *field,
+			   uint32_t oneof_case,
+			   const void *member, ProtobufCBuffer *buffer)
+{
+	if (oneof_case != field->id) {
+		return 0;
+	}
+	if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
+	    field->type == PROTOBUF_C_TYPE_STRING)
+	{
+		const void *ptr = *(const void *const *) member;
+		if (ptr == NULL || ptr == field->default_value)
+			return 0;
+	}
+	return required_field_pack_to_buffer(field, member, buffer);
+}
+
+/**
+ * Pack an optional field to a buffer.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param has
+ *      Whether the field is set.
+ * \param member
+ *      The element to be packed.
+ * \param[out] buffer
+ *      Virtual buffer to append data to.
+ * \return
+ *      Number of bytes serialised to `buffer`.
+ */
+static size_t
+optional_field_pack_to_buffer(const ProtobufCFieldDescriptor *field,
+			      const protobuf_c_boolean has,
+			      const void *member, ProtobufCBuffer *buffer)
+{
+	if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
+	    field->type == PROTOBUF_C_TYPE_STRING)
+	{
+		const void *ptr = *(const void *const *) member;
+		if (ptr == NULL || ptr == field->default_value)
+			return 0;
+	} else {
+		if (!has)
+			return 0;
+	}
+	return required_field_pack_to_buffer(field, member, buffer);
+}
+
+/**
+ * Pack an unlabeled field to a buffer.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param member
+ *      The element to be packed.
+ * \param[out] buffer
+ *      Virtual buffer to append data to.
+ * \return
+ *      Number of bytes serialised to `buffer`.
+ */
+static size_t
+unlabeled_field_pack_to_buffer(const ProtobufCFieldDescriptor *field,
+			       const void *member, ProtobufCBuffer *buffer)
+{
+	if (field_is_zeroish(field, member))
+		return 0;
+	return required_field_pack_to_buffer(field, member, buffer);
+}
+
+/**
+ * Get the packed size of an array of same field type.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param count
+ *      Number of elements of this type.
+ * \param array
+ *      The elements to get the size of.
+ * \return
+ *      Number of bytes required.
+ */
+static size_t
+get_packed_payload_length(const ProtobufCFieldDescriptor *field,
+			  unsigned count, const void *array)
+{
+	unsigned rv = 0;
+	unsigned i;
+
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+		return count * 4;
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		return count * 8;
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32: {
+		const int32_t *arr = (const int32_t *) array;
+		for (i = 0; i < count; i++)
+			rv += int32_size(arr[i]);
+		break;
+	}
+	case PROTOBUF_C_TYPE_SINT32: {
+		const int32_t *arr = (const int32_t *) array;
+		for (i = 0; i < count; i++)
+			rv += sint32_size(arr[i]);
+		break;
+	}
+	case PROTOBUF_C_TYPE_UINT32: {
+		const uint32_t *arr = (const uint32_t *) array;
+		for (i = 0; i < count; i++)
+			rv += uint32_size(arr[i]);
+		break;
+	}
+	case PROTOBUF_C_TYPE_SINT64: {
+		const int64_t *arr = (const int64_t *) array;
+		for (i = 0; i < count; i++)
+			rv += sint64_size(arr[i]);
+		break;
+	}
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64: {
+		const uint64_t *arr = (const uint64_t *) array;
+		for (i = 0; i < count; i++)
+			rv += uint64_size(arr[i]);
+		break;
+	}
+	case PROTOBUF_C_TYPE_BOOL:
+		return count;
+	default:
+		PROTOBUF_C__ASSERT_NOT_REACHED();
+	}
+	return rv;
+}
+
+/**
+ * Pack an array of same field type to a virtual buffer.
+ *
+ * \param field
+ *      Field descriptor.
+ * \param count
+ *      Number of elements of this type.
+ * \param array
+ *      The elements to get the size of.
+ * \param[out] buffer
+ *      Virtual buffer to append data to.
+ * \return
+ *      Number of bytes packed.
+ */
+static size_t
+pack_buffer_packed_payload(const ProtobufCFieldDescriptor *field,
+			   unsigned count, const void *array,
+			   ProtobufCBuffer *buffer)
+{
+	uint8_t scratch[16];
+	size_t rv = 0;
+	unsigned i;
+
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+#if !defined(WORDS_BIGENDIAN)
+		rv = count * 4;
+		goto no_packing_needed;
+#else
+		for (i = 0; i < count; i++) {
+			unsigned len = fixed32_pack(((uint32_t *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		break;
+#endif
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+#if !defined(WORDS_BIGENDIAN)
+		rv = count * 8;
+		goto no_packing_needed;
+#else
+		for (i = 0; i < count; i++) {
+			unsigned len = fixed64_pack(((uint64_t *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		break;
+#endif
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+		for (i = 0; i < count; i++) {
+			unsigned len = int32_pack(((int32_t *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		break;
+	case PROTOBUF_C_TYPE_SINT32:
+		for (i = 0; i < count; i++) {
+			unsigned len = sint32_pack(((int32_t *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		break;
+	case PROTOBUF_C_TYPE_UINT32:
+		for (i = 0; i < count; i++) {
+			unsigned len = uint32_pack(((uint32_t *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		break;
+	case PROTOBUF_C_TYPE_SINT64:
+		for (i = 0; i < count; i++) {
+			unsigned len = sint64_pack(((int64_t *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		break;
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		for (i = 0; i < count; i++) {
+			unsigned len = uint64_pack(((uint64_t *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		break;
+	case PROTOBUF_C_TYPE_BOOL:
+		for (i = 0; i < count; i++) {
+			unsigned len = boolean_pack(((protobuf_c_boolean *) array)[i], scratch);
+			buffer->append(buffer, len, scratch);
+			rv += len;
+		}
+		return count;
+	default:
+		PROTOBUF_C__ASSERT_NOT_REACHED();
+	}
+	return rv;
+
+#if !defined(WORDS_BIGENDIAN)
+no_packing_needed:
+	buffer->append(buffer, rv, array);
+	return rv;
+#endif
+}
+
+static size_t
+repeated_field_pack_to_buffer(const ProtobufCFieldDescriptor *field,
+			      unsigned count, const void *member,
+			      ProtobufCBuffer *buffer)
+{
+	char *array = *(char * const *) member;
+
+	if (count == 0)
+		return 0;
+	if (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED)) {
+		uint8_t scratch[MAX_UINT64_ENCODED_SIZE * 2];
+		size_t rv = tag_pack(field->id, scratch);
+		size_t payload_len = get_packed_payload_length(field, count, array);
+		size_t tmp;
+
+		scratch[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+		rv += uint32_pack(payload_len, scratch + rv);
+		buffer->append(buffer, rv, scratch);
+		tmp = pack_buffer_packed_payload(field, count, array, buffer);
+		assert(tmp == payload_len);
+		return rv + payload_len;
+	} else {
+		size_t siz;
+		unsigned i;
+		/* CONSIDER: optimize this case a bit (by putting the loop inside the switch) */
+		unsigned rv = 0;
+
+		siz = sizeof_elt_in_repeated_array(field->type);
+		for (i = 0; i < count; i++) {
+			rv += required_field_pack_to_buffer(field, array, buffer);
+			array += siz;
+		}
+		return rv;
+	}
+}
+
+static size_t
+unknown_field_pack_to_buffer(const ProtobufCMessageUnknownField *field,
+			     ProtobufCBuffer *buffer)
+{
+	uint8_t header[MAX_UINT64_ENCODED_SIZE];
+	size_t rv = tag_pack(field->tag, header);
+
+	header[0] |= field->wire_type;
+	buffer->append(buffer, rv, header);
+	buffer->append(buffer, field->len, field->data);
+	return rv + field->len;
+}
+
+/**@}*/
+
+size_t
+protobuf_c_message_pack_to_buffer(const ProtobufCMessage *message,
+				  ProtobufCBuffer *buffer)
+{
+	unsigned i;
+	size_t rv = 0;
+
+	ASSERT_IS_MESSAGE(message);
+	for (i = 0; i < message->descriptor->n_fields; i++) {
+		const ProtobufCFieldDescriptor *field =
+			message->descriptor->fields + i;
+		const void *member =
+			((const char *) message) + field->offset;
+		const void *qmember =
+			((const char *) message) + field->quantifier_offset;
+
+		if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
+			rv += required_field_pack_to_buffer(field, member, buffer);
+		} else if ((field->label == PROTOBUF_C_LABEL_OPTIONAL ||
+			    field->label == PROTOBUF_C_LABEL_NONE) &&
+			   (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_ONEOF))) {
+			rv += oneof_field_pack_to_buffer(
+				field,
+				*(const uint32_t *) qmember,
+				member,
+				buffer
+			);
+		} else if (field->label == PROTOBUF_C_LABEL_OPTIONAL) {
+			rv += optional_field_pack_to_buffer(
+				field,
+				*(const protobuf_c_boolean *) qmember,
+				member,
+				buffer
+			);
+		} else if (field->label == PROTOBUF_C_LABEL_NONE) {
+			rv += unlabeled_field_pack_to_buffer(
+				field,
+				member,
+				buffer
+			);
+		} else {
+			rv += repeated_field_pack_to_buffer(
+				field,
+				*(const size_t *) qmember,
+				member,
+				buffer
+			);
+		}
+	}
+	for (i = 0; i < message->n_unknown_fields; i++)
+		rv += unknown_field_pack_to_buffer(&message->unknown_fields[i], buffer);
+
+	return rv;
+}
+
+/**
+ * \defgroup unpack unpacking implementation
+ *
+ * Routines mainly used by the unpacking functions.
+ *
+ * \ingroup internal
+ * @{
+ */
+
+static inline int
+int_range_lookup(unsigned n_ranges, const ProtobufCIntRange *ranges, int value)
+{
+	unsigned n;
+	unsigned start;
+
+	if (n_ranges == 0)
+		return -1;
+	start = 0;
+	n = n_ranges;
+	while (n > 1) {
+		unsigned mid = start + n / 2;
+
+		if (value < ranges[mid].start_value) {
+			n = mid - start;
+		} else if (value >= ranges[mid].start_value +
+			   (int) (ranges[mid + 1].orig_index -
+				  ranges[mid].orig_index))
+		{
+			unsigned new_start = mid + 1;
+			n = start + n - new_start;
+			start = new_start;
+		} else
+			return (value - ranges[mid].start_value) +
+			    ranges[mid].orig_index;
+	}
+	if (n > 0) {
+		unsigned start_orig_index = ranges[start].orig_index;
+		unsigned range_size =
+			ranges[start + 1].orig_index - start_orig_index;
+
+		if (ranges[start].start_value <= value &&
+		    value < (int) (ranges[start].start_value + range_size))
+		{
+			return (value - ranges[start].start_value) +
+			    start_orig_index;
+		}
+	}
+	return -1;
+}
+
+static size_t
+parse_tag_and_wiretype(size_t len,
+		       const uint8_t *data,
+		       uint32_t *tag_out,
+		       uint8_t *wiretype_out)
+{
+	unsigned max_rv = len > 5 ? 5 : len;
+	uint32_t tag = (data[0] & 0x7f) >> 3;
+	unsigned shift = 4;
+	unsigned rv;
+
+	/* 0 is not a valid tag value */
+	if ((data[0] & 0xf8) == 0) {
+		return 0;
+	}
+
+	*wiretype_out = data[0] & 7;
+	if ((data[0] & 0x80) == 0) {
+		*tag_out = tag;
+		return 1;
+	}
+	for (rv = 1; rv < max_rv; rv++) {
+		if (data[rv] & 0x80) {
+			tag |= (data[rv] & 0x7f) << shift;
+			shift += 7;
+		} else {
+			tag |= data[rv] << shift;
+			*tag_out = tag;
+			return rv + 1;
+		}
+	}
+	return 0; /* error: bad header */
+}
+
+/* sizeof(ScannedMember) must be <= (1UL<<BOUND_SIZEOF_SCANNED_MEMBER_LOG2) */
+#define BOUND_SIZEOF_SCANNED_MEMBER_LOG2 5
+typedef struct ScannedMember ScannedMember;
+/** Field as it's being read. */
+struct ScannedMember {
+	uint32_t tag;              /**< Field tag. */
+	uint8_t wire_type;         /**< Field type. */
+	uint8_t length_prefix_len; /**< Prefix length. */
+	const ProtobufCFieldDescriptor *field; /**< Field descriptor. */
+	size_t len;                /**< Field length. */
+	const uint8_t *data;       /**< Pointer to field data. */
+};
+
+static inline size_t
+scan_length_prefixed_data(size_t len, const uint8_t *data,
+			  size_t *prefix_len_out)
+{
+	unsigned hdr_max = len < 5 ? len : 5;
+	unsigned hdr_len;
+	size_t val = 0;
+	unsigned i;
+	unsigned shift = 0;
+
+	for (i = 0; i < hdr_max; i++) {
+		val |= ((size_t)data[i] & 0x7f) << shift;
+		shift += 7;
+		if ((data[i] & 0x80) == 0)
+			break;
+	}
+	if (i == hdr_max) {
+		PROTOBUF_C_UNPACK_ERROR("error parsing length for length-prefixed data");
+		return 0;
+	}
+	hdr_len = i + 1;
+	*prefix_len_out = hdr_len;
+	if (val > INT_MAX) {
+		// Protobuf messages should always be less than 2 GiB in size.
+		// We also want to return early here so that hdr_len + val does
+		// not overflow on 32-bit systems.
+		PROTOBUF_C_UNPACK_ERROR("length prefix of %lu is too large",
+			(unsigned long int)val);
+		return 0;
+	}
+	if (hdr_len + val > len) {
+		PROTOBUF_C_UNPACK_ERROR("data too short after length-prefix of %lu",
+			(unsigned long int)val);
+		return 0;
+	}
+	return hdr_len + val;
+}
+
+static size_t
+max_b128_numbers(size_t len, const uint8_t *data)
+{
+	size_t rv = 0;
+	while (len--)
+		if ((*data++ & 0x80) == 0)
+			++rv;
+	return rv;
+}
+
+/**@}*/
+
+/**
+ * Merge earlier message into a latter message.
+ *
+ * For numeric types and strings, if the same value appears multiple
+ * times, the parser accepts the last value it sees. For embedded
+ * message fields, the parser merges multiple instances of the same
+ * field. That is, all singular scalar fields in the latter instance
+ * replace those in the former, singular embedded messages are merged,
+ * and repeated fields are concatenated.
+ *
+ * The earlier message should be freed after calling this function, as
+ * some of its fields may have been reused and changed to their default
+ * values during the merge.
+ */
+static protobuf_c_boolean
+merge_messages(ProtobufCMessage *earlier_msg,
+	       ProtobufCMessage *latter_msg,
+	       ProtobufCAllocator *allocator)
+{
+	unsigned i;
+	const ProtobufCFieldDescriptor *fields =
+		latter_msg->descriptor->fields;
+	for (i = 0; i < latter_msg->descriptor->n_fields; i++) {
+		if (fields[i].label == PROTOBUF_C_LABEL_REPEATED) {
+			size_t *n_earlier =
+				STRUCT_MEMBER_PTR(size_t, earlier_msg,
+						  fields[i].quantifier_offset);
+			uint8_t **p_earlier =
+				STRUCT_MEMBER_PTR(uint8_t *, earlier_msg,
+						  fields[i].offset);
+			size_t *n_latter =
+				STRUCT_MEMBER_PTR(size_t, latter_msg,
+						  fields[i].quantifier_offset);
+			uint8_t **p_latter =
+				STRUCT_MEMBER_PTR(uint8_t *, latter_msg,
+						  fields[i].offset);
+
+			if (*n_earlier > 0) {
+				if (*n_latter > 0) {
+					/* Concatenate the repeated field */
+					size_t el_size =
+						sizeof_elt_in_repeated_array(fields[i].type);
+					uint8_t *new_field;
+
+					new_field = do_alloc(allocator,
+						(*n_earlier + *n_latter) * el_size);
+					if (!new_field)
+						return FALSE;
+
+					memcpy(new_field, *p_earlier,
+					       *n_earlier * el_size);
+					memcpy(new_field +
+					       *n_earlier * el_size,
+					       *p_latter,
+					       *n_latter * el_size);
+
+					do_free(allocator, *p_latter);
+					do_free(allocator, *p_earlier);
+					*p_latter = new_field;
+					*n_latter = *n_earlier + *n_latter;
+				} else {
+					/* Zero copy the repeated field from the earlier message */
+					*n_latter = *n_earlier;
+					*p_latter = *p_earlier;
+				}
+				/* Make sure the field does not get double freed */
+				*n_earlier = 0;
+				*p_earlier = 0;
+			}
+		} else if (fields[i].label == PROTOBUF_C_LABEL_OPTIONAL ||
+			   fields[i].label == PROTOBUF_C_LABEL_NONE) {
+			const ProtobufCFieldDescriptor *field;
+			uint32_t *earlier_case_p = STRUCT_MEMBER_PTR(uint32_t,
+								     earlier_msg,
+								     fields[i].
+								     quantifier_offset);
+			uint32_t *latter_case_p = STRUCT_MEMBER_PTR(uint32_t,
+								    latter_msg,
+								    fields[i].
+								    quantifier_offset);
+			protobuf_c_boolean need_to_merge = FALSE;
+			void *earlier_elem;
+			void *latter_elem;
+			const void *def_val;
+
+			if (fields[i].flags & PROTOBUF_C_FIELD_FLAG_ONEOF) {
+				if (*latter_case_p == 0) {
+					/* lookup correct oneof field */
+					int field_index =
+						int_range_lookup(
+							latter_msg->descriptor
+							->n_field_ranges,
+							latter_msg->descriptor
+							->field_ranges,
+							*earlier_case_p);
+					if (field_index < 0)
+						return FALSE;
+					field = latter_msg->descriptor->fields +
+						field_index;
+				} else {
+					/* Oneof is present in the latter message, move on */
+					continue;
+				}
+			} else {
+				field = &fields[i];
+			}
+
+			earlier_elem = STRUCT_MEMBER_P(earlier_msg, field->offset);
+			latter_elem = STRUCT_MEMBER_P(latter_msg, field->offset);
+			def_val = field->default_value;
+
+			switch (field->type) {
+			case PROTOBUF_C_TYPE_MESSAGE: {
+				ProtobufCMessage *em = *(ProtobufCMessage **) earlier_elem;
+				ProtobufCMessage *lm = *(ProtobufCMessage **) latter_elem;
+				if (em != NULL) {
+					if (lm != NULL) {
+						if (!merge_messages(em, lm, allocator))
+							return FALSE;
+						/* Already merged */
+						need_to_merge = FALSE;
+					} else {
+						/* Zero copy the message */
+						need_to_merge = TRUE;
+					}
+				}
+				break;
+			}
+			case PROTOBUF_C_TYPE_BYTES: {
+				uint8_t *e_data =
+					((ProtobufCBinaryData *) earlier_elem)->data;
+				uint8_t *l_data =
+					((ProtobufCBinaryData *) latter_elem)->data;
+				const ProtobufCBinaryData *d_bd =
+					(ProtobufCBinaryData *) def_val;
+
+				need_to_merge =
+					(e_data != NULL &&
+					 (d_bd == NULL ||
+					  e_data != d_bd->data)) &&
+					(l_data == NULL ||
+					 (d_bd != NULL &&
+					  l_data == d_bd->data));
+				break;
+			}
+			case PROTOBUF_C_TYPE_STRING: {
+				char *e_str = *(char **) earlier_elem;
+				char *l_str = *(char **) latter_elem;
+				const char *d_str = def_val;
+
+				need_to_merge = e_str != d_str && l_str == d_str;
+				break;
+			}
+			default: {
+				/* Could be has field or case enum, the logic is
+				 * equivalent, since 0 (FALSE) means not set for
+				 * oneof */
+				need_to_merge = (*earlier_case_p != 0) &&
+						(*latter_case_p == 0);
+				break;
+			}
+			}
+
+			if (need_to_merge) {
+				size_t el_size =
+					sizeof_elt_in_repeated_array(field->type);
+				memcpy(latter_elem, earlier_elem, el_size);
+				/*
+				 * Reset the element from the old message to 0
+				 * to make sure earlier message deallocation
+				 * doesn't corrupt zero-copied data in the new
+				 * message, earlier message will be freed after
+				 * this function is called anyway
+				 */
+				memset(earlier_elem, 0, el_size);
+
+				if (field->quantifier_offset != 0) {
+					/* Set the has field or the case enum,
+					 * if applicable */
+					*latter_case_p = *earlier_case_p;
+					*earlier_case_p = 0;
+				}
+			}
+		}
+	}
+	return TRUE;
+}
+
+/**
+ * Count packed elements.
+ *
+ * Given a raw slab of packed-repeated values, determine the number of
+ * elements. This function detects certain kinds of errors but not
+ * others; the remaining error checking is done by
+ * parse_packed_repeated_member().
+ */
+static protobuf_c_boolean
+count_packed_elements(ProtobufCType type,
+		      size_t len, const uint8_t *data, size_t *count_out)
+{
+	switch (type) {
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+		if (len % 4 != 0) {
+			PROTOBUF_C_UNPACK_ERROR("length must be a multiple of 4 for fixed-length 32-bit types");
+			return FALSE;
+		}
+		*count_out = len / 4;
+		return TRUE;
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		if (len % 8 != 0) {
+			PROTOBUF_C_UNPACK_ERROR("length must be a multiple of 8 for fixed-length 64-bit types");
+			return FALSE;
+		}
+		*count_out = len / 8;
+		return TRUE;
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+	case PROTOBUF_C_TYPE_SINT32:
+	case PROTOBUF_C_TYPE_UINT32:
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_SINT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		*count_out = max_b128_numbers(len, data);
+		return TRUE;
+	case PROTOBUF_C_TYPE_BOOL:
+		*count_out = len;
+		return TRUE;
+	case PROTOBUF_C_TYPE_STRING:
+	case PROTOBUF_C_TYPE_BYTES:
+	case PROTOBUF_C_TYPE_MESSAGE:
+	default:
+		PROTOBUF_C_UNPACK_ERROR("bad protobuf-c type %u for packed-repeated", type);
+		return FALSE;
+	}
+}
+
+static inline uint32_t
+parse_uint32(unsigned len, const uint8_t *data)
+{
+	uint32_t rv = data[0] & 0x7f;
+	if (len > 1) {
+		rv |= ((uint32_t) (data[1] & 0x7f) << 7);
+		if (len > 2) {
+			rv |= ((uint32_t) (data[2] & 0x7f) << 14);
+			if (len > 3) {
+				rv |= ((uint32_t) (data[3] & 0x7f) << 21);
+				if (len > 4)
+					rv |= ((uint32_t) (data[4]) << 28);
+			}
+		}
+	}
+	return rv;
+}
+
+static inline uint32_t
+parse_int32(unsigned len, const uint8_t *data)
+{
+	return parse_uint32(len, data);
+}
+
+static inline int32_t
+unzigzag32(uint32_t v)
+{
+	// Note:  Using unsigned types prevents undefined behavior
+	return (int32_t)((v >> 1) ^ -(v & 1));
+}
+
+static inline uint32_t
+parse_fixed_uint32(const uint8_t *data)
+{
+#if !defined(WORDS_BIGENDIAN)
+	uint32_t t;
+	memcpy(&t, data, 4);
+	return t;
+#else
+	return data[0] |
+		((uint32_t) (data[1]) << 8) |
+		((uint32_t) (data[2]) << 16) |
+		((uint32_t) (data[3]) << 24);
+#endif
+}
+
+static uint64_t
+parse_uint64(unsigned len, const uint8_t *data)
+{
+	unsigned shift, i;
+	uint64_t rv;
+
+	if (len < 5)
+		return parse_uint32(len, data);
+	rv = ((uint64_t) (data[0] & 0x7f)) |
+		((uint64_t) (data[1] & 0x7f) << 7) |
+		((uint64_t) (data[2] & 0x7f) << 14) |
+		((uint64_t) (data[3] & 0x7f) << 21);
+	shift = 28;
+	for (i = 4; i < len; i++) {
+		rv |= (((uint64_t) (data[i] & 0x7f)) << shift);
+		shift += 7;
+	}
+	return rv;
+}
+
+static inline int64_t
+unzigzag64(uint64_t v)
+{
+	// Note:  Using unsigned types prevents undefined behavior
+	return (int64_t)((v >> 1) ^ -(v & 1));
+}
+
+static inline uint64_t
+parse_fixed_uint64(const uint8_t *data)
+{
+#if !defined(WORDS_BIGENDIAN)
+	uint64_t t;
+	memcpy(&t, data, 8);
+	return t;
+#else
+	return (uint64_t) parse_fixed_uint32(data) |
+		(((uint64_t) parse_fixed_uint32(data + 4)) << 32);
+#endif
+}
+
+static protobuf_c_boolean
+parse_boolean(unsigned len, const uint8_t *data)
+{
+	unsigned i;
+	for (i = 0; i < len; i++)
+		if (data[i] & 0x7f)
+			return TRUE;
+	return FALSE;
+}
+
+static protobuf_c_boolean
+parse_required_member(ScannedMember *scanned_member,
+		      void *member,
+		      ProtobufCAllocator *allocator,
+		      protobuf_c_boolean maybe_clear)
+{
+	unsigned len = scanned_member->len;
+	const uint8_t *data = scanned_member->data;
+	uint8_t wire_type = scanned_member->wire_type;
+
+	switch (scanned_member->field->type) {
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
+			return FALSE;
+		*(int32_t *) member = parse_int32(len, data);
+		return TRUE;
+	case PROTOBUF_C_TYPE_UINT32:
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
+			return FALSE;
+		*(uint32_t *) member = parse_uint32(len, data);
+		return TRUE;
+	case PROTOBUF_C_TYPE_SINT32:
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
+			return FALSE;
+		*(int32_t *) member = unzigzag32(parse_uint32(len, data));
+		return TRUE;
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_32BIT)
+			return FALSE;
+		*(uint32_t *) member = parse_fixed_uint32(data);
+		return TRUE;
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
+			return FALSE;
+		*(uint64_t *) member = parse_uint64(len, data);
+		return TRUE;
+	case PROTOBUF_C_TYPE_SINT64:
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
+			return FALSE;
+		*(int64_t *) member = unzigzag64(parse_uint64(len, data));
+		return TRUE;
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_64BIT)
+			return FALSE;
+		*(uint64_t *) member = parse_fixed_uint64(data);
+		return TRUE;
+	case PROTOBUF_C_TYPE_BOOL:
+		*(protobuf_c_boolean *) member = parse_boolean(len, data);
+		return TRUE;
+	case PROTOBUF_C_TYPE_STRING: {
+		char **pstr = member;
+		unsigned pref_len = scanned_member->length_prefix_len;
+
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED)
+			return FALSE;
+
+		if (maybe_clear && *pstr != NULL) {
+			const char *def = scanned_member->field->default_value;
+			if (*pstr != NULL && *pstr != def)
+				do_free(allocator, *pstr);
+		}
+		*pstr = do_alloc(allocator, len - pref_len + 1);
+		if (*pstr == NULL)
+			return FALSE;
+		memcpy(*pstr, data + pref_len, len - pref_len);
+		(*pstr)[len - pref_len] = 0;
+		return TRUE;
+	}
+	case PROTOBUF_C_TYPE_BYTES: {
+		ProtobufCBinaryData *bd = member;
+		const ProtobufCBinaryData *def_bd;
+		unsigned pref_len = scanned_member->length_prefix_len;
+
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED)
+			return FALSE;
+
+		def_bd = scanned_member->field->default_value;
+		if (maybe_clear &&
+		    bd->data != NULL &&
+		    (def_bd == NULL || bd->data != def_bd->data))
+		{
+			do_free(allocator, bd->data);
+		}
+		if (len > pref_len) {
+			bd->data = do_alloc(allocator, len - pref_len);
+			if (bd->data == NULL)
+				return FALSE;
+			memcpy(bd->data, data + pref_len, len - pref_len);
+		} else {
+			bd->data = NULL;
+		}
+		bd->len = len - pref_len;
+		return TRUE;
+	}
+	case PROTOBUF_C_TYPE_MESSAGE: {
+		ProtobufCMessage **pmessage = member;
+		ProtobufCMessage *subm;
+		const ProtobufCMessage *def_mess;
+		protobuf_c_boolean merge_successful = TRUE;
+		unsigned pref_len = scanned_member->length_prefix_len;
+
+		if (wire_type != PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED)
+			return FALSE;
+
+		def_mess = scanned_member->field->default_value;
+		if (len >= pref_len)
+			subm = protobuf_c_message_unpack(scanned_member->field->descriptor,
+							 allocator,
+							 len - pref_len,
+							 data + pref_len);
+		else
+			subm = NULL;
+
+		if (maybe_clear &&
+		    *pmessage != NULL &&
+		    *pmessage != def_mess)
+		{
+			if (subm != NULL)
+				merge_successful = merge_messages(*pmessage, subm, allocator);
+			/* Delete the previous message */
+			protobuf_c_message_free_unpacked(*pmessage, allocator);
+		}
+		*pmessage = subm;
+		if (subm == NULL || !merge_successful)
+			return FALSE;
+		return TRUE;
+	}
+	}
+	return FALSE;
+}
+
+static protobuf_c_boolean
+parse_oneof_member (ScannedMember *scanned_member,
+		    void *member,
+		    ProtobufCMessage *message,
+		    ProtobufCAllocator *allocator)
+{
+	uint32_t *oneof_case = STRUCT_MEMBER_PTR(uint32_t, message,
+					       scanned_member->field->quantifier_offset);
+
+	/* If we have already parsed a member of this oneof, free it. */
+	if (*oneof_case != 0) {
+		const ProtobufCFieldDescriptor *old_field;
+		size_t el_size;
+		/* lookup field */
+		int field_index =
+			int_range_lookup(message->descriptor->n_field_ranges,
+					 message->descriptor->field_ranges,
+					 *oneof_case);
+		if (field_index < 0)
+			return FALSE;
+		old_field = message->descriptor->fields + field_index;
+		el_size = sizeof_elt_in_repeated_array(old_field->type);
+
+		switch (old_field->type) {
+	        case PROTOBUF_C_TYPE_STRING: {
+			char **pstr = member;
+			const char *def = old_field->default_value;
+			if (*pstr != NULL && *pstr != def)
+				do_free(allocator, *pstr);
+			break;
+	        }
+		case PROTOBUF_C_TYPE_BYTES: {
+			ProtobufCBinaryData *bd = member;
+			const ProtobufCBinaryData *def_bd = old_field->default_value;
+			if (bd->data != NULL &&
+			   (def_bd == NULL || bd->data != def_bd->data))
+			{
+				do_free(allocator, bd->data);
+			}
+			break;
+	        }
+		case PROTOBUF_C_TYPE_MESSAGE: {
+			ProtobufCMessage **pmessage = member;
+			const ProtobufCMessage *def_mess = old_field->default_value;
+			if (*pmessage != NULL && *pmessage != def_mess)
+				protobuf_c_message_free_unpacked(*pmessage, allocator);
+			break;
+	        }
+		default:
+			break;
+		}
+
+		memset (member, 0, el_size);
+	}
+	if (!parse_required_member (scanned_member, member, allocator, TRUE))
+		return FALSE;
+
+	*oneof_case = scanned_member->tag;
+	return TRUE;
+}
+
+
+static protobuf_c_boolean
+parse_optional_member(ScannedMember *scanned_member,
+		      void *member,
+		      ProtobufCMessage *message,
+		      ProtobufCAllocator *allocator)
+{
+	if (!parse_required_member(scanned_member, member, allocator, TRUE))
+		return FALSE;
+	if (scanned_member->field->quantifier_offset != 0)
+		STRUCT_MEMBER(protobuf_c_boolean,
+			      message,
+			      scanned_member->field->quantifier_offset) = TRUE;
+	return TRUE;
+}
+
+static protobuf_c_boolean
+parse_repeated_member(ScannedMember *scanned_member,
+		      void *member,
+		      ProtobufCMessage *message,
+		      ProtobufCAllocator *allocator)
+{
+	const ProtobufCFieldDescriptor *field = scanned_member->field;
+	size_t *p_n = STRUCT_MEMBER_PTR(size_t, message, field->quantifier_offset);
+	size_t siz = sizeof_elt_in_repeated_array(field->type);
+	char *array = *(char **) member;
+
+	if (!parse_required_member(scanned_member, array + siz * (*p_n),
+				   allocator, FALSE))
+	{
+		return FALSE;
+	}
+	*p_n += 1;
+	return TRUE;
+}
+
+static unsigned
+scan_varint(unsigned len, const uint8_t *data)
+{
+	unsigned i;
+	if (len > 10)
+		len = 10;
+	for (i = 0; i < len; i++)
+		if ((data[i] & 0x80) == 0)
+			break;
+	if (i == len)
+		return 0;
+	return i + 1;
+}
+
+static protobuf_c_boolean
+parse_packed_repeated_member(ScannedMember *scanned_member,
+			     void *member,
+			     ProtobufCMessage *message)
+{
+	const ProtobufCFieldDescriptor *field = scanned_member->field;
+	size_t *p_n = STRUCT_MEMBER_PTR(size_t, message, field->quantifier_offset);
+	size_t siz = sizeof_elt_in_repeated_array(field->type);
+	void *array = *(char **) member + siz * (*p_n);
+	const uint8_t *at = scanned_member->data + scanned_member->length_prefix_len;
+	size_t rem = scanned_member->len - scanned_member->length_prefix_len;
+	size_t count = 0;
+#if defined(WORDS_BIGENDIAN)
+	unsigned i;
+#endif
+
+	switch (field->type) {
+	case PROTOBUF_C_TYPE_SFIXED32:
+	case PROTOBUF_C_TYPE_FIXED32:
+	case PROTOBUF_C_TYPE_FLOAT:
+		count = (scanned_member->len - scanned_member->length_prefix_len) / 4;
+#if !defined(WORDS_BIGENDIAN)
+		goto no_unpacking_needed;
+#else
+		for (i = 0; i < count; i++) {
+			((uint32_t *) array)[i] = parse_fixed_uint32(at);
+			at += 4;
+		}
+		break;
+#endif
+	case PROTOBUF_C_TYPE_SFIXED64:
+	case PROTOBUF_C_TYPE_FIXED64:
+	case PROTOBUF_C_TYPE_DOUBLE:
+		count = (scanned_member->len - scanned_member->length_prefix_len) / 8;
+#if !defined(WORDS_BIGENDIAN)
+		goto no_unpacking_needed;
+#else
+		for (i = 0; i < count; i++) {
+			((uint64_t *) array)[i] = parse_fixed_uint64(at);
+			at += 8;
+		}
+		break;
+#endif
+	case PROTOBUF_C_TYPE_ENUM:
+	case PROTOBUF_C_TYPE_INT32:
+		while (rem > 0) {
+			unsigned s = scan_varint(rem, at);
+			if (s == 0) {
+				PROTOBUF_C_UNPACK_ERROR("bad packed-repeated int32 value");
+				return FALSE;
+			}
+			((int32_t *) array)[count++] = parse_int32(s, at);
+			at += s;
+			rem -= s;
+		}
+		break;
+	case PROTOBUF_C_TYPE_SINT32:
+		while (rem > 0) {
+			unsigned s = scan_varint(rem, at);
+			if (s == 0) {
+				PROTOBUF_C_UNPACK_ERROR("bad packed-repeated sint32 value");
+				return FALSE;
+			}
+			((int32_t *) array)[count++] = unzigzag32(parse_uint32(s, at));
+			at += s;
+			rem -= s;
+		}
+		break;
+	case PROTOBUF_C_TYPE_UINT32:
+		while (rem > 0) {
+			unsigned s = scan_varint(rem, at);
+			if (s == 0) {
+				PROTOBUF_C_UNPACK_ERROR("bad packed-repeated enum or uint32 value");
+				return FALSE;
+			}
+			((uint32_t *) array)[count++] = parse_uint32(s, at);
+			at += s;
+			rem -= s;
+		}
+		break;
+
+	case PROTOBUF_C_TYPE_SINT64:
+		while (rem > 0) {
+			unsigned s = scan_varint(rem, at);
+			if (s == 0) {
+				PROTOBUF_C_UNPACK_ERROR("bad packed-repeated sint64 value");
+				return FALSE;
+			}
+			((int64_t *) array)[count++] = unzigzag64(parse_uint64(s, at));
+			at += s;
+			rem -= s;
+		}
+		break;
+	case PROTOBUF_C_TYPE_INT64:
+	case PROTOBUF_C_TYPE_UINT64:
+		while (rem > 0) {
+			unsigned s = scan_varint(rem, at);
+			if (s == 0) {
+				PROTOBUF_C_UNPACK_ERROR("bad packed-repeated int64/uint64 value");
+				return FALSE;
+			}
+			((int64_t *) array)[count++] = parse_uint64(s, at);
+			at += s;
+			rem -= s;
+		}
+		break;
+	case PROTOBUF_C_TYPE_BOOL:
+		while (rem > 0) {
+			unsigned s = scan_varint(rem, at);
+			if (s == 0) {
+				PROTOBUF_C_UNPACK_ERROR("bad packed-repeated boolean value");
+				return FALSE;
+			}
+			((protobuf_c_boolean *) array)[count++] = parse_boolean(s, at);
+			at += s;
+			rem -= s;
+		}
+		break;
+	default:
+		PROTOBUF_C__ASSERT_NOT_REACHED();
+	}
+	*p_n += count;
+	return TRUE;
+
+#if !defined(WORDS_BIGENDIAN)
+no_unpacking_needed:
+	memcpy(array, at, count * siz);
+	*p_n += count;
+	return TRUE;
+#endif
+}
+
+static protobuf_c_boolean
+is_packable_type(ProtobufCType type)
+{
+	return
+		type != PROTOBUF_C_TYPE_STRING &&
+		type != PROTOBUF_C_TYPE_BYTES &&
+		type != PROTOBUF_C_TYPE_MESSAGE;
+}
+
+static protobuf_c_boolean
+parse_member(ScannedMember *scanned_member,
+	     ProtobufCMessage *message,
+	     ProtobufCAllocator *allocator)
+{
+	const ProtobufCFieldDescriptor *field = scanned_member->field;
+	void *member;
+
+	if (field == NULL) {
+		ProtobufCMessageUnknownField *ufield =
+			message->unknown_fields +
+			(message->n_unknown_fields++);
+		ufield->tag = scanned_member->tag;
+		ufield->wire_type = scanned_member->wire_type;
+		ufield->len = scanned_member->len;
+		ufield->data = do_alloc(allocator, scanned_member->len);
+		if (ufield->data == NULL)
+			return FALSE;
+		memcpy(ufield->data, scanned_member->data, ufield->len);
+		return TRUE;
+	}
+	member = (char *) message + field->offset;
+	switch (field->label) {
+	case PROTOBUF_C_LABEL_REQUIRED:
+		return parse_required_member(scanned_member, member,
+					     allocator, TRUE);
+	case PROTOBUF_C_LABEL_OPTIONAL:
+	case PROTOBUF_C_LABEL_NONE:
+		if (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_ONEOF)) {
+			return parse_oneof_member(scanned_member, member,
+						  message, allocator);
+		} else {
+			return parse_optional_member(scanned_member, member,
+						     message, allocator);
+		}
+	case PROTOBUF_C_LABEL_REPEATED:
+		if (scanned_member->wire_type ==
+		    PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED &&
+		    (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED) ||
+		     is_packable_type(field->type)))
+		{
+			return parse_packed_repeated_member(scanned_member,
+							    member, message);
+		} else {
+			return parse_repeated_member(scanned_member,
+						     member, message,
+						     allocator);
+		}
+	}
+	PROTOBUF_C__ASSERT_NOT_REACHED();
+	return 0;
+}
+
+/**
+ * Initialise messages generated by old code.
+ *
+ * This function is used if desc->message_init == NULL (which occurs
+ * for old code, and which would be useful to support allocating
+ * descriptors dynamically).
+ */
+void message_init_generic(const ProtobufCMessageDescriptor *desc, ProtobufCMessage *message)
+{
+	unsigned i;
+
+	memset(message, 0, desc->sizeof_message);
+	message->descriptor = desc;
+	for (i = 0; i < desc->n_fields; i++) {
+		if (desc->fields[i].default_value != NULL &&
+		    desc->fields[i].label != PROTOBUF_C_LABEL_REPEATED)
+		{
+			void *field =
+				STRUCT_MEMBER_P(message, desc->fields[i].offset);
+			const void *dv = desc->fields[i].default_value;
+
+			switch (desc->fields[i].type) {
+			case PROTOBUF_C_TYPE_INT32:
+			case PROTOBUF_C_TYPE_SINT32:
+			case PROTOBUF_C_TYPE_SFIXED32:
+			case PROTOBUF_C_TYPE_UINT32:
+			case PROTOBUF_C_TYPE_FIXED32:
+			case PROTOBUF_C_TYPE_FLOAT:
+			case PROTOBUF_C_TYPE_ENUM:
+				memcpy(field, dv, 4);
+				break;
+			case PROTOBUF_C_TYPE_INT64:
+			case PROTOBUF_C_TYPE_SINT64:
+			case PROTOBUF_C_TYPE_SFIXED64:
+			case PROTOBUF_C_TYPE_UINT64:
+			case PROTOBUF_C_TYPE_FIXED64:
+			case PROTOBUF_C_TYPE_DOUBLE:
+				memcpy(field, dv, 8);
+				break;
+			case PROTOBUF_C_TYPE_BOOL:
+				memcpy(field, dv, sizeof(protobuf_c_boolean));
+				break;
+			case PROTOBUF_C_TYPE_BYTES:
+				memcpy(field, dv, sizeof(ProtobufCBinaryData));
+				break;
+
+			case PROTOBUF_C_TYPE_STRING:
+			case PROTOBUF_C_TYPE_MESSAGE:
+				/*
+				 * The next line essentially implements a cast
+				 * from const, which is totally unavoidable.
+				 */
+				*(const void **) field = dv;
+				break;
+			}
+		}
+	}
+}
+
+/**@}*/
+
+/*
+ * ScannedMember slabs (an unpacking implementation detail). Before doing real
+ * unpacking, we first scan through the elements to see how many there are (for
+ * repeated fields), and which field to use (for non-repeated fields given
+ * twice).
+ *
+ * In order to avoid allocations for small messages, we keep a stack-allocated
+ * slab of ScannedMembers of size FIRST_SCANNED_MEMBER_SLAB_SIZE (16). After we
+ * fill that up, we allocate each slab twice as large as the previous one.
+ */
+#define FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2 4
+
+/*
+ * The number of slabs, including the stack-allocated ones; choose the number so
+ * that we would overflow if we needed a slab larger than provided.
+ */
+#define MAX_SCANNED_MEMBER_SLAB			\
+  (sizeof(unsigned int)*8 - 1			\
+   - BOUND_SIZEOF_SCANNED_MEMBER_LOG2		\
+   - FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2)
+
+#define REQUIRED_FIELD_BITMAP_SET(index)	\
+	(required_fields_bitmap[(index)/8] |= (1UL<<((index)%8)))
+
+#define REQUIRED_FIELD_BITMAP_IS_SET(index)	\
+	(required_fields_bitmap[(index)/8] & (1UL<<((index)%8)))
+
+ProtobufCMessage *
+protobuf_c_message_unpack(const ProtobufCMessageDescriptor *desc,
+			  ProtobufCAllocator *allocator,
+			  size_t len, const uint8_t *data)
+{
+	ProtobufCMessage *rv;
+	size_t rem = len;
+	const uint8_t *at = data;
+	const ProtobufCFieldDescriptor *last_field = desc->fields + 0;
+	ScannedMember first_member_slab[1UL <<
+					FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2];
+
+	/*
+	 * scanned_member_slabs[i] is an array of arrays of ScannedMember.
+	 * The first slab (scanned_member_slabs[0] is just a pointer to
+	 * first_member_slab), above. All subsequent slabs will be allocated
+	 * using the allocator.
+	 */
+	ScannedMember *scanned_member_slabs[MAX_SCANNED_MEMBER_SLAB + 1];
+	unsigned which_slab = 0; /* the slab we are currently populating */
+	unsigned in_slab_index = 0; /* number of members in the slab */
+	size_t n_unknown = 0;
+	unsigned f;
+	unsigned j;
+	unsigned i_slab;
+	unsigned last_field_index = 0;
+	unsigned required_fields_bitmap_len;
+	unsigned char required_fields_bitmap_stack[16];
+	unsigned char *required_fields_bitmap = required_fields_bitmap_stack;
+	protobuf_c_boolean required_fields_bitmap_alloced = FALSE;
+
+	ASSERT_IS_MESSAGE_DESCRIPTOR(desc);
+
+	if (allocator == NULL)
+		allocator = &protobuf_c__allocator;
+
+	rv = do_alloc(allocator, desc->sizeof_message);
+	if (!rv)
+		return (NULL);
+	scanned_member_slabs[0] = first_member_slab;
+
+	required_fields_bitmap_len = (desc->n_fields + 7) / 8;
+	if (required_fields_bitmap_len > sizeof(required_fields_bitmap_stack)) {
+		required_fields_bitmap = do_alloc(allocator, required_fields_bitmap_len);
+		if (!required_fields_bitmap) {
+			do_free(allocator, rv);
+			return (NULL);
+		}
+		required_fields_bitmap_alloced = TRUE;
+	}
+	memset(required_fields_bitmap, 0, required_fields_bitmap_len);
+
+	/*
+	 * Generated code always defines "message_init". However, we provide a
+	 * fallback for (1) users of old protobuf-c generated-code that do not
+	 * provide the function, and (2) descriptors constructed from some other
+	 * source (most likely, direct construction from the .proto file).
+	 */
+	if (desc->message_init != NULL)
+		protobuf_c_message_init(desc, rv);
+	else
+		message_init_generic(desc, rv);
+
+	while (rem > 0) {
+		uint32_t tag;
+		uint8_t wire_type;
+		size_t used = parse_tag_and_wiretype(rem, at, &tag, &wire_type);
+		const ProtobufCFieldDescriptor *field;
+		ScannedMember tmp;
+
+		if (used == 0) {
+			PROTOBUF_C_UNPACK_ERROR("error parsing tag/wiretype at offset %u",
+						(unsigned) (at - data));
+			goto error_cleanup_during_scan;
+		}
+		/*
+		 * \todo Consider optimizing for field[1].id == tag, if field[1]
+		 * exists!
+		 */
+		if (last_field == NULL || last_field->id != tag) {
+			/* lookup field */
+			int field_index =
+			    int_range_lookup(desc->n_field_ranges,
+					     desc->field_ranges,
+					     tag);
+			if (field_index < 0) {
+				field = NULL;
+				n_unknown++;
+			} else {
+				field = desc->fields + field_index;
+				last_field = field;
+				last_field_index = field_index;
+			}
+		} else {
+			field = last_field;
+		}
+
+		if (field != NULL && field->label == PROTOBUF_C_LABEL_REQUIRED)
+			REQUIRED_FIELD_BITMAP_SET(last_field_index);
+
+		at += used;
+		rem -= used;
+		tmp.tag = tag;
+		tmp.wire_type = wire_type;
+		tmp.field = field;
+		tmp.data = at;
+		tmp.length_prefix_len = 0;
+
+		switch (wire_type) {
+		case PROTOBUF_C_WIRE_TYPE_VARINT: {
+			unsigned max_len = rem < 10 ? rem : 10;
+			unsigned i;
+
+			for (i = 0; i < max_len; i++)
+				if ((at[i] & 0x80) == 0)
+					break;
+			if (i == max_len) {
+				PROTOBUF_C_UNPACK_ERROR("unterminated varint at offset %u",
+							(unsigned) (at - data));
+				goto error_cleanup_during_scan;
+			}
+			tmp.len = i + 1;
+			break;
+		}
+		case PROTOBUF_C_WIRE_TYPE_64BIT:
+			if (rem < 8) {
+				PROTOBUF_C_UNPACK_ERROR("too short after 64bit wiretype at offset %u",
+							(unsigned) (at - data));
+				goto error_cleanup_during_scan;
+			}
+			tmp.len = 8;
+			break;
+		case PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED: {
+			size_t pref_len;
+
+			tmp.len = scan_length_prefixed_data(rem, at, &pref_len);
+			if (tmp.len == 0) {
+				/* NOTE: scan_length_prefixed_data calls UNPACK_ERROR */
+				goto error_cleanup_during_scan;
+			}
+			tmp.length_prefix_len = pref_len;
+			break;
+		}
+		case PROTOBUF_C_WIRE_TYPE_32BIT:
+			if (rem < 4) {
+				PROTOBUF_C_UNPACK_ERROR("too short after 32bit wiretype at offset %u",
+					      (unsigned) (at - data));
+				goto error_cleanup_during_scan;
+			}
+			tmp.len = 4;
+			break;
+		default:
+			PROTOBUF_C_UNPACK_ERROR("unsupported tag %u at offset %u",
+						wire_type, (unsigned) (at - data));
+			goto error_cleanup_during_scan;
+		}
+
+		if (in_slab_index == (1UL <<
+			(which_slab + FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2)))
+		{
+			size_t size;
+
+			in_slab_index = 0;
+			if (which_slab == MAX_SCANNED_MEMBER_SLAB) {
+				PROTOBUF_C_UNPACK_ERROR("too many fields");
+				goto error_cleanup_during_scan;
+			}
+			which_slab++;
+			size = sizeof(ScannedMember)
+				<< (which_slab + FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2);
+			scanned_member_slabs[which_slab] = do_alloc(allocator, size);
+			if (scanned_member_slabs[which_slab] == NULL)
+				goto error_cleanup_during_scan;
+		}
+		scanned_member_slabs[which_slab][in_slab_index++] = tmp;
+
+		if (field != NULL && field->label == PROTOBUF_C_LABEL_REPEATED) {
+			size_t *n = STRUCT_MEMBER_PTR(size_t, rv,
+						      field->quantifier_offset);
+			if (wire_type == PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED &&
+			    (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED) ||
+			     is_packable_type(field->type)))
+			{
+				size_t count;
+				if (!count_packed_elements(field->type,
+							   tmp.len -
+							   tmp.length_prefix_len,
+							   tmp.data +
+							   tmp.length_prefix_len,
+							   &count))
+				{
+					PROTOBUF_C_UNPACK_ERROR("counting packed elements");
+					goto error_cleanup_during_scan;
+				}
+				*n += count;
+			} else {
+				*n += 1;
+			}
+		}
+
+		at += tmp.len;
+		rem -= tmp.len;
+	}
+
+	/* allocate space for repeated fields, also check that all required fields have been set */
+	for (f = 0; f < desc->n_fields; f++) {
+		const ProtobufCFieldDescriptor *field = desc->fields + f;
+		if (field == NULL) {
+			continue;
+		}
+		if (field->label == PROTOBUF_C_LABEL_REPEATED) {
+			size_t siz =
+			    sizeof_elt_in_repeated_array(field->type);
+			size_t *n_ptr =
+			    STRUCT_MEMBER_PTR(size_t, rv,
+					      field->quantifier_offset);
+			if (*n_ptr != 0) {
+				unsigned n = *n_ptr;
+				void *a;
+				*n_ptr = 0;
+				assert(rv->descriptor != NULL);
+#define CLEAR_REMAINING_N_PTRS()                                              \
+              for(f++;f < desc->n_fields; f++)                                \
+                {                                                             \
+                  field = desc->fields + f;                                   \
+                  if (field->label == PROTOBUF_C_LABEL_REPEATED)              \
+                    STRUCT_MEMBER (size_t, rv, field->quantifier_offset) = 0; \
+                }
+				a = do_alloc(allocator, siz * n);
+				if (!a) {
+					CLEAR_REMAINING_N_PTRS();
+					goto error_cleanup;
+				}
+				STRUCT_MEMBER(void *, rv, field->offset) = a;
+			}
+		} else if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
+			if (field->default_value == NULL &&
+			    !REQUIRED_FIELD_BITMAP_IS_SET(f))
+			{
+				CLEAR_REMAINING_N_PTRS();
+				PROTOBUF_C_UNPACK_ERROR("message '%s': missing required field '%s'",
+							desc->name, field->name);
+				goto error_cleanup;
+			}
+		}
+	}
+#undef CLEAR_REMAINING_N_PTRS
+
+	/* allocate space for unknown fields */
+	if (n_unknown) {
+		rv->unknown_fields = do_alloc(allocator,
+					      n_unknown * sizeof(ProtobufCMessageUnknownField));
+		if (rv->unknown_fields == NULL)
+			goto error_cleanup;
+	}
+
+	/* do real parsing */
+	for (i_slab = 0; i_slab <= which_slab; i_slab++) {
+		unsigned max = (i_slab == which_slab) ?
+			in_slab_index : (1UL << (i_slab + 4));
+		ScannedMember *slab = scanned_member_slabs[i_slab];
+
+		for (j = 0; j < max; j++) {
+			if (!parse_member(slab + j, rv, allocator)) {
+				PROTOBUF_C_UNPACK_ERROR("error parsing member %s of %s",
+							slab->field ? slab->field->name : "*unknown-field*",
+					desc->name);
+				goto error_cleanup;
+			}
+		}
+	}
+
+	/* cleanup */
+	for (j = 1; j <= which_slab; j++)
+		do_free(allocator, scanned_member_slabs[j]);
+	if (required_fields_bitmap_alloced)
+		do_free(allocator, required_fields_bitmap);
+	return rv;
+
+error_cleanup:
+	protobuf_c_message_free_unpacked(rv, allocator);
+	for (j = 1; j <= which_slab; j++)
+		do_free(allocator, scanned_member_slabs[j]);
+	if (required_fields_bitmap_alloced)
+		do_free(allocator, required_fields_bitmap);
+	return NULL;
+
+error_cleanup_during_scan:
+	do_free(allocator, rv);
+	for (j = 1; j <= which_slab; j++)
+		do_free(allocator, scanned_member_slabs[j]);
+	if (required_fields_bitmap_alloced)
+		do_free(allocator, required_fields_bitmap);
+	return NULL;
+}
+
+void
+protobuf_c_message_free_unpacked(ProtobufCMessage *message,
+				 ProtobufCAllocator *allocator)
+{
+	const ProtobufCMessageDescriptor *desc;
+	unsigned f;
+
+	if (message == NULL)
+		return;
+
+	desc = message->descriptor;
+
+	ASSERT_IS_MESSAGE(message);
+
+	if (allocator == NULL)
+		allocator = &protobuf_c__allocator;
+	message->descriptor = NULL;
+	for (f = 0; f < desc->n_fields; f++) {
+		if (0 != (desc->fields[f].flags & PROTOBUF_C_FIELD_FLAG_ONEOF) &&
+		    desc->fields[f].id !=
+		    STRUCT_MEMBER(uint32_t, message, desc->fields[f].quantifier_offset))
+		{
+			/* This is not the selected oneof, skip it */
+			continue;
+		}
+
+		if (desc->fields[f].label == PROTOBUF_C_LABEL_REPEATED) {
+			size_t n = STRUCT_MEMBER(size_t,
+						 message,
+						 desc->fields[f].quantifier_offset);
+			void *arr = STRUCT_MEMBER(void *,
+						  message,
+						  desc->fields[f].offset);
+
+			if (arr != NULL) {
+				if (desc->fields[f].type == PROTOBUF_C_TYPE_STRING) {
+					unsigned i;
+					for (i = 0; i < n; i++)
+						do_free(allocator, ((char **) arr)[i]);
+				} else if (desc->fields[f].type == PROTOBUF_C_TYPE_BYTES) {
+					unsigned i;
+					for (i = 0; i < n; i++)
+						do_free(allocator, ((ProtobufCBinaryData *) arr)[i].data);
+				} else if (desc->fields[f].type == PROTOBUF_C_TYPE_MESSAGE) {
+					unsigned i;
+					for (i = 0; i < n; i++)
+						protobuf_c_message_free_unpacked(
+							((ProtobufCMessage **) arr)[i],
+							allocator
+						);
+				}
+				do_free(allocator, arr);
+			}
+		} else if (desc->fields[f].type == PROTOBUF_C_TYPE_STRING) {
+			char *str = STRUCT_MEMBER(char *, message,
+						  desc->fields[f].offset);
+
+			if (str && str != desc->fields[f].default_value)
+				do_free(allocator, str);
+		} else if (desc->fields[f].type == PROTOBUF_C_TYPE_BYTES) {
+			void *data = STRUCT_MEMBER(ProtobufCBinaryData, message,
+						   desc->fields[f].offset).data;
+			const ProtobufCBinaryData *default_bd;
+
+			default_bd = desc->fields[f].default_value;
+			if (data != NULL &&
+			    (default_bd == NULL ||
+			     default_bd->data != data))
+			{
+				do_free(allocator, data);
+			}
+		} else if (desc->fields[f].type == PROTOBUF_C_TYPE_MESSAGE) {
+			ProtobufCMessage *sm;
+
+			sm = STRUCT_MEMBER(ProtobufCMessage *, message,
+					   desc->fields[f].offset);
+			if (sm && sm != desc->fields[f].default_value)
+				protobuf_c_message_free_unpacked(sm, allocator);
+		}
+	}
+
+	for (f = 0; f < message->n_unknown_fields; f++)
+		do_free(allocator, message->unknown_fields[f].data);
+	if (message->unknown_fields != NULL)
+		do_free(allocator, message->unknown_fields);
+
+	do_free(allocator, message);
+}
+
+void
+protobuf_c_message_init(const ProtobufCMessageDescriptor * descriptor,
+			void *message)
+{
+	descriptor->message_init((ProtobufCMessage *) (message));
+}
+
+protobuf_c_boolean
+protobuf_c_message_check(const ProtobufCMessage *message)
+{
+	unsigned i;
+
+	if (!message ||
+	    !message->descriptor ||
+	    message->descriptor->magic != PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC)
+	{
+		return FALSE;
+	}
+
+	for (i = 0; i < message->descriptor->n_fields; i++) {
+		const ProtobufCFieldDescriptor *f = message->descriptor->fields + i;
+		ProtobufCType type = f->type;
+		ProtobufCLabel label = f->label;
+		void *field = STRUCT_MEMBER_P (message, f->offset);
+
+		if (f->flags & PROTOBUF_C_FIELD_FLAG_ONEOF) {
+			const uint32_t *oneof_case = STRUCT_MEMBER_P (message, f->quantifier_offset);
+			if (f->id != *oneof_case) {
+				continue; //Do not check if it is an unpopulated oneof member.
+			}
+		}
+
+		if (label == PROTOBUF_C_LABEL_REPEATED) {
+			size_t *quantity = STRUCT_MEMBER_P (message, f->quantifier_offset);
+
+			if (*quantity > 0 && *(void **) field == NULL) {
+				return FALSE;
+			}
+
+			if (type == PROTOBUF_C_TYPE_MESSAGE) {
+				ProtobufCMessage **submessage = *(ProtobufCMessage ***) field;
+				unsigned j;
+				for (j = 0; j < *quantity; j++) {
+					if (!protobuf_c_message_check(submessage[j]))
+						return FALSE;
+				}
+			} else if (type == PROTOBUF_C_TYPE_STRING) {
+				char **string = *(char ***) field;
+				unsigned j;
+				for (j = 0; j < *quantity; j++) {
+					if (!string[j])
+						return FALSE;
+				}
+			} else if (type == PROTOBUF_C_TYPE_BYTES) {
+				ProtobufCBinaryData *bd = *(ProtobufCBinaryData **) field;
+				unsigned j;
+				for (j = 0; j < *quantity; j++) {
+					if (bd[j].len > 0 && bd[j].data == NULL)
+						return FALSE;
+				}
+			}
+
+		} else { /* PROTOBUF_C_LABEL_REQUIRED or PROTOBUF_C_LABEL_OPTIONAL */
+
+			if (type == PROTOBUF_C_TYPE_MESSAGE) {
+				ProtobufCMessage *submessage = *(ProtobufCMessage **) field;
+				if (label == PROTOBUF_C_LABEL_REQUIRED || submessage != NULL) {
+					if (!protobuf_c_message_check(submessage))
+						return FALSE;
+				}
+			} else if (type == PROTOBUF_C_TYPE_STRING) {
+				char *string = *(char **) field;
+				if (label == PROTOBUF_C_LABEL_REQUIRED && string == NULL)
+					return FALSE;
+			} else if (type == PROTOBUF_C_TYPE_BYTES) {
+				protobuf_c_boolean *has = STRUCT_MEMBER_P (message, f->quantifier_offset);
+				ProtobufCBinaryData *bd = field;
+				if (label == PROTOBUF_C_LABEL_REQUIRED || *has == TRUE) {
+					if (bd->len > 0 && bd->data == NULL)
+						return FALSE;
+				}
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+/* === services === */
+
+typedef void (*GenericHandler) (void *service,
+				const ProtobufCMessage *input,
+				ProtobufCClosure closure,
+				void *closure_data);
+void
+protobuf_c_service_invoke_internal(ProtobufCService *service,
+				   unsigned method_index,
+				   const ProtobufCMessage *input,
+				   ProtobufCClosure closure,
+				   void *closure_data)
+{
+	GenericHandler *handlers;
+	GenericHandler handler;
+
+	/*
+	 * Verify that method_index is within range. If this fails, you are
+	 * likely invoking a newly added method on an old service. (Although
+	 * other memory corruption bugs can cause this assertion too.)
+	 */
+	assert(method_index < service->descriptor->n_methods);
+
+	/*
+	 * Get the array of virtual methods (which are enumerated by the
+	 * generated code).
+	 */
+	handlers = (GenericHandler *) (service + 1);
+
+	/*
+	 * Get our method and invoke it.
+	 * \todo Seems like handler == NULL is a situation that needs handling.
+	 */
+	handler = handlers[method_index];
+	(*handler)(service, input, closure, closure_data);
+}
+
+void
+protobuf_c_service_generated_init(ProtobufCService *service,
+				  const ProtobufCServiceDescriptor *descriptor,
+				  ProtobufCServiceDestroy destroy)
+{
+	ASSERT_IS_SERVICE_DESCRIPTOR(descriptor);
+	service->descriptor = descriptor;
+	service->destroy = destroy;
+	service->invoke = protobuf_c_service_invoke_internal;
+	memset(service + 1, 0, descriptor->n_methods * sizeof(GenericHandler));
+}
+
+void protobuf_c_service_destroy(ProtobufCService *service)
+{
+	service->destroy(service);
+}
+
+/* --- querying the descriptors --- */
+
+const ProtobufCEnumValue *
+protobuf_c_enum_descriptor_get_value_by_name(const ProtobufCEnumDescriptor *desc,
+					     const char *name)
+{
+	unsigned start = 0;
+	unsigned count;
+
+	if (desc == NULL || desc->values_by_name == NULL)
+		return NULL;
+
+	count = desc->n_value_names;
+
+	while (count > 1) {
+		unsigned mid = start + count / 2;
+		int rv = strcmp(desc->values_by_name[mid].name, name);
+		if (rv == 0)
+			return desc->values + desc->values_by_name[mid].index;
+		else if (rv < 0) {
+			count = start + count - (mid + 1);
+			start = mid + 1;
+		} else
+			count = mid - start;
+	}
+	if (count == 0)
+		return NULL;
+	if (strcmp(desc->values_by_name[start].name, name) == 0)
+		return desc->values + desc->values_by_name[start].index;
+	return NULL;
+}
+
+const ProtobufCEnumValue *
+protobuf_c_enum_descriptor_get_value(const ProtobufCEnumDescriptor *desc,
+				     int value)
+{
+	int rv = int_range_lookup(desc->n_value_ranges, desc->value_ranges, value);
+	if (rv < 0)
+		return NULL;
+	return desc->values + rv;
+}
+
+const ProtobufCFieldDescriptor *
+protobuf_c_message_descriptor_get_field_by_name(const ProtobufCMessageDescriptor *desc,
+						const char *name)
+{
+	unsigned start = 0;
+	unsigned count;
+	const ProtobufCFieldDescriptor *field;
+
+	if (desc == NULL || desc->fields_sorted_by_name == NULL)
+		return NULL;
+
+	count = desc->n_fields;
+
+	while (count > 1) {
+		unsigned mid = start + count / 2;
+		int rv;
+		field = desc->fields + desc->fields_sorted_by_name[mid];
+		rv = strcmp(field->name, name);
+		if (rv == 0)
+			return field;
+		else if (rv < 0) {
+			count = start + count - (mid + 1);
+			start = mid + 1;
+		} else
+			count = mid - start;
+	}
+	if (count == 0)
+		return NULL;
+	field = desc->fields + desc->fields_sorted_by_name[start];
+	if (strcmp(field->name, name) == 0)
+		return field;
+	return NULL;
+}
+
+const ProtobufCFieldDescriptor *
+protobuf_c_message_descriptor_get_field(const ProtobufCMessageDescriptor *desc,
+					unsigned value)
+{
+	int rv = int_range_lookup(desc->n_field_ranges,desc->field_ranges, value);
+	if (rv < 0)
+		return NULL;
+	return desc->fields + rv;
+}
+
+const ProtobufCMethodDescriptor *
+protobuf_c_service_descriptor_get_method_by_name(const ProtobufCServiceDescriptor *desc,
+						 const char *name)
+{
+	unsigned start = 0;
+	unsigned count;
+
+	if (desc == NULL || desc->method_indices_by_name == NULL)
+		return NULL;
+
+	count = desc->n_methods;
+
+	while (count > 1) {
+		unsigned mid = start + count / 2;
+		unsigned mid_index = desc->method_indices_by_name[mid];
+		const char *mid_name = desc->methods[mid_index].name;
+		int rv = strcmp(mid_name, name);
+
+		if (rv == 0)
+			return desc->methods + desc->method_indices_by_name[mid];
+		if (rv < 0) {
+			count = start + count - (mid + 1);
+			start = mid + 1;
+		} else {
+			count = mid - start;
+		}
+	}
+	if (count == 0)
+		return NULL;
+	if (strcmp(desc->methods[desc->method_indices_by_name[start]].name, name) == 0)
+		return desc->methods + desc->method_indices_by_name[start];
+	return NULL;
+}
diff --git a/protocols/Steam/src/protobuf-c/protobuf-c.h b/protocols/Steam/src/protobuf-c/protobuf-c.h
new file mode 100644
index 0000000000..23b38fecd3
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/protobuf-c.h
@@ -0,0 +1,1122 @@
+/*
+ * Copyright (c) 2008-2022, Dave Benson and the protobuf-c authors.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ * \mainpage Introduction
+ *
+ * This is [protobuf-c], a C implementation of [Protocol Buffers].
+ *
+ * This file defines the public API for the `libprotobuf-c` support library.
+ * This API includes interfaces that can be used directly by client code as well
+ * as the interfaces used by the code generated by the `protoc-c` compiler.
+ *
+ * The `libprotobuf-c` support library performs the actual serialization and
+ * deserialization of Protocol Buffers messages. It interacts with structures,
+ * definitions, and metadata generated by the `protoc-c` compiler from .proto
+ * files.
+ *
+ * \authors Dave Benson and the `protobuf-c` authors.
+ *
+ * \copyright 2008-2014. Licensed under the terms of the [BSD-2-Clause] license.
+ *
+ * [protobuf-c]:       https://github.com/protobuf-c/protobuf-c
+ * [Protocol Buffers]: https://developers.google.com/protocol-buffers/
+ * [BSD-2-Clause]:     http://opensource.org/licenses/BSD-2-Clause
+ *
+ * \page gencode Generated Code
+ *
+ * For each enum, we generate a C enum. For each message, we generate a C
+ * structure which can be cast to a `ProtobufCMessage`.
+ *
+ * For each enum and message, we generate a descriptor object that allows us to
+ * implement a kind of reflection on the structures.
+ *
+ * First, some naming conventions:
+ *
+ * - The name of the type for enums and messages and services is camel case
+ *   (meaning WordsAreCrammedTogether) except that double underscores are used
+ *   to delimit scopes. For example, the following `.proto` file:
+ *
+~~~{.proto}
+        package foo.bar;
+        message BazBah {
+            optional int32 val = 1;
+        }
+~~~
+ *
+ * would generate a C type `Foo__Bar__BazBah`.
+ *
+ * - Identifiers for functions and globals are all lowercase, with camel case
+ *   words separated by single underscores. For example, one of the function
+ *   prototypes generated by `protoc-c` for the above example:
+ *
+~~~{.c}
+Foo__Bar__BazBah *
+       foo__bar__baz_bah__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+~~~
+ *
+ * - Identifiers for enum values contain an uppercase prefix which embeds the
+ *   package name and the enum type name.
+ *
+ * - A double underscore is used to separate further components of identifier
+ *   names.
+ *
+ * For example, in the name of the unpack function above, the package name
+ * `foo.bar` has become `foo__bar`, the message name BazBah has become
+ * `baz_bah`, and the method name is `unpack`. These are all joined with double
+ * underscores to form the C identifier `foo__bar__baz_bah__unpack`.
+ *
+ * We also generate descriptor objects for messages and enums. These are
+ * declared in the `.pb-c.h` files:
+ *
+~~~{.c}
+extern const ProtobufCMessageDescriptor foo__bar__baz_bah__descriptor;
+~~~
+ *
+ * The message structures all begin with `ProtobufCMessageDescriptor *` which is
+ * sufficient to allow them to be cast to `ProtobufCMessage`.
+ *
+ * For each message defined in a `.proto` file, we generate a number of
+ * functions and macros. Each function name contains a prefix based on the
+ * package name and message name in order to make it a unique C identifier.
+ *
+ * - `INIT`. Statically initializes a message object, initializing its
+ *   descriptor and setting its fields to default values. Uninitialized
+ *   messages cannot be processed by the protobuf-c library.
+ *
+~~~{.c}
+#define FOO__BAR__BAZ_BAH__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&foo__bar__baz_bah__descriptor), 0 }
+~~~
+ * - `init()`. Initializes a message object, initializing its descriptor and
+ *   setting its fields to default values. Uninitialized messages cannot be
+ *   processed by the protobuf-c library.
+ *
+~~~{.c}
+void foo__bar__baz_bah__init
+                     (Foo__Bar__BazBah *message);
+~~~
+ * - `unpack()`. Unpacks data for a particular message format. Note that the
+ *   `allocator` parameter is usually `NULL` to indicate that the system's
+ *   `malloc()` and `free()` functions should be used for dynamically allocating
+ *   memory.
+ *
+~~~{.c}
+Foo__Bar__BazBah *
+       foo__bar__baz_bah__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+~~~
+ *
+ * - `free_unpacked()`. Frees a message object obtained with the `unpack()`
+ *   method. Freeing `NULL` is allowed (the same as with `free()`).
+ *
+~~~{.c}
+void   foo__bar__baz_bah__free_unpacked
+                     (Foo__Bar__BazBah *message,
+                      ProtobufCAllocator *allocator);
+~~~
+ *
+ * - `get_packed_size()`. Calculates the length in bytes of the serialized
+ *   representation of the message object.
+ *
+~~~{.c}
+size_t foo__bar__baz_bah__get_packed_size
+                     (const Foo__Bar__BazBah   *message);
+~~~
+ *
+ * - `pack()`. Pack a message object into a preallocated buffer. Assumes that
+ *   the buffer is large enough. (Use `get_packed_size()` first.)
+ *
+~~~{.c}
+size_t foo__bar__baz_bah__pack
+                     (const Foo__Bar__BazBah   *message,
+                      uint8_t             *out);
+~~~
+ *
+ * - `pack_to_buffer()`. Packs a message into a "virtual buffer". This is an
+ *   object which defines an "append bytes" callback to consume data as it is
+ *   serialized.
+ *
+~~~{.c}
+size_t foo__bar__baz_bah__pack_to_buffer
+                     (const Foo__Bar__BazBah   *message,
+                      ProtobufCBuffer     *buffer);
+~~~
+ *
+ * \page pack Packing and unpacking messages
+ *
+ * To pack a message, first compute the packed size of the message with
+ * protobuf_c_message_get_packed_size(), then allocate a buffer of at least
+ * that size, then call protobuf_c_message_pack().
+ *
+ * Alternatively, a message can be serialized without calculating the final size
+ * first. Use the protobuf_c_message_pack_to_buffer() function and provide a
+ * ProtobufCBuffer object which implements an "append" method that consumes
+ * data.
+ *
+ * To unpack a message, call the protobuf_c_message_unpack() function. The
+ * result can be cast to an object of the type that matches the descriptor for
+ * the message.
+ *
+ * The result of unpacking a message should be freed with
+ * protobuf_c_message_free_unpacked().
+ */
+
+#ifndef PROTOBUF_C_H
+#define PROTOBUF_C_H
+
+#include <assert.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+# define PROTOBUF_C__BEGIN_DECLS	extern "C" {
+# define PROTOBUF_C__END_DECLS		}
+#else
+# define PROTOBUF_C__BEGIN_DECLS
+# define PROTOBUF_C__END_DECLS
+#endif
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if defined(_WIN32) && defined(PROTOBUF_C_USE_SHARED_LIB)
+# ifdef PROTOBUF_C_EXPORT
+#  define PROTOBUF_C__API __declspec(dllexport)
+# else
+#  define PROTOBUF_C__API __declspec(dllimport)
+# endif
+#else
+# define PROTOBUF_C__API
+#endif
+
+#if !defined(PROTOBUF_C__NO_DEPRECATED) && \
+	((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+# define PROTOBUF_C__DEPRECATED __attribute__((__deprecated__))
+#else
+# define PROTOBUF_C__DEPRECATED
+#endif
+
+#ifndef PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE
+ #define PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(enum_name) \
+  , _##enum_name##_IS_INT_SIZE = INT_MAX
+#endif
+
+#define PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC    0x14159bc3
+#define PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC    0x28aaeef9
+#define PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC       0x114315af
+
+/* Empty string used for initializers */
+#if defined(_WIN32) && defined(PROTOBUF_C_USE_SHARED_LIB)
+static const char protobuf_c_empty_string[] = "";
+#else
+extern const char protobuf_c_empty_string[];
+#endif
+
+/**
+ * \defgroup api Public API
+ *
+ * This is the public API for `libprotobuf-c`. These interfaces are stable and
+ * subject to Semantic Versioning guarantees.
+ *
+ * @{
+ */
+
+/**
+ * Values for the `flags` word in `ProtobufCFieldDescriptor`.
+ */
+typedef enum {
+	/** Set if the field is repeated and marked with the `packed` option. */
+	PROTOBUF_C_FIELD_FLAG_PACKED		= (1 << 0),
+
+	/** Set if the field is marked with the `deprecated` option. */
+	PROTOBUF_C_FIELD_FLAG_DEPRECATED	= (1 << 1),
+
+	/** Set if the field is a member of a oneof (union). */
+	PROTOBUF_C_FIELD_FLAG_ONEOF		= (1 << 2),
+} ProtobufCFieldFlag;
+
+/**
+ * Message field rules.
+ *
+ * \see [Defining A Message Type] in the Protocol Buffers documentation.
+ *
+ * [Defining A Message Type]:
+ *      https://developers.google.com/protocol-buffers/docs/proto#simple
+ */
+typedef enum {
+	/** A well-formed message must have exactly one of this field. */
+	PROTOBUF_C_LABEL_REQUIRED,
+
+	/**
+	 * A well-formed message can have zero or one of this field (but not
+	 * more than one).
+	 */
+	PROTOBUF_C_LABEL_OPTIONAL,
+
+	/**
+	 * This field can be repeated any number of times (including zero) in a
+	 * well-formed message. The order of the repeated values will be
+	 * preserved.
+	 */
+	PROTOBUF_C_LABEL_REPEATED,
+
+	/**
+	 * This field has no label. This is valid only in proto3 and is
+	 * equivalent to OPTIONAL but no "has" quantifier will be consulted.
+	 */
+	PROTOBUF_C_LABEL_NONE,
+} ProtobufCLabel;
+
+/**
+ * Field value types.
+ *
+ * \see [Scalar Value Types] in the Protocol Buffers documentation.
+ *
+ * [Scalar Value Types]:
+ *      https://developers.google.com/protocol-buffers/docs/proto#scalar
+ */
+typedef enum {
+	PROTOBUF_C_TYPE_INT32,      /**< int32 */
+	PROTOBUF_C_TYPE_SINT32,     /**< signed int32 */
+	PROTOBUF_C_TYPE_SFIXED32,   /**< signed int32 (4 bytes) */
+	PROTOBUF_C_TYPE_INT64,      /**< int64 */
+	PROTOBUF_C_TYPE_SINT64,     /**< signed int64 */
+	PROTOBUF_C_TYPE_SFIXED64,   /**< signed int64 (8 bytes) */
+	PROTOBUF_C_TYPE_UINT32,     /**< unsigned int32 */
+	PROTOBUF_C_TYPE_FIXED32,    /**< unsigned int32 (4 bytes) */
+	PROTOBUF_C_TYPE_UINT64,     /**< unsigned int64 */
+	PROTOBUF_C_TYPE_FIXED64,    /**< unsigned int64 (8 bytes) */
+	PROTOBUF_C_TYPE_FLOAT,      /**< float */
+	PROTOBUF_C_TYPE_DOUBLE,     /**< double */
+	PROTOBUF_C_TYPE_BOOL,       /**< boolean */
+	PROTOBUF_C_TYPE_ENUM,       /**< enumerated type */
+	PROTOBUF_C_TYPE_STRING,     /**< UTF-8 or ASCII string */
+	PROTOBUF_C_TYPE_BYTES,      /**< arbitrary byte sequence */
+	PROTOBUF_C_TYPE_MESSAGE,    /**< nested message */
+} ProtobufCType;
+
+/**
+ * Field wire types.
+ *
+ * \see [Message Structure] in the Protocol Buffers documentation.
+ *
+ * [Message Structure]:
+ *      https://developers.google.com/protocol-buffers/docs/encoding#structure
+ */
+typedef enum {
+	PROTOBUF_C_WIRE_TYPE_VARINT = 0,
+	PROTOBUF_C_WIRE_TYPE_64BIT = 1,
+	PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED = 2,
+	/* "Start group" and "end group" wire types are unsupported. */
+	PROTOBUF_C_WIRE_TYPE_32BIT = 5,
+} ProtobufCWireType;
+
+struct ProtobufCAllocator;
+struct ProtobufCBinaryData;
+struct ProtobufCBuffer;
+struct ProtobufCBufferSimple;
+struct ProtobufCEnumDescriptor;
+struct ProtobufCEnumValue;
+struct ProtobufCEnumValueIndex;
+struct ProtobufCFieldDescriptor;
+struct ProtobufCIntRange;
+struct ProtobufCMessage;
+struct ProtobufCMessageDescriptor;
+struct ProtobufCMessageUnknownField;
+struct ProtobufCMethodDescriptor;
+struct ProtobufCService;
+struct ProtobufCServiceDescriptor;
+
+typedef struct ProtobufCAllocator ProtobufCAllocator;
+typedef struct ProtobufCBinaryData ProtobufCBinaryData;
+typedef struct ProtobufCBuffer ProtobufCBuffer;
+typedef struct ProtobufCBufferSimple ProtobufCBufferSimple;
+typedef struct ProtobufCEnumDescriptor ProtobufCEnumDescriptor;
+typedef struct ProtobufCEnumValue ProtobufCEnumValue;
+typedef struct ProtobufCEnumValueIndex ProtobufCEnumValueIndex;
+typedef struct ProtobufCFieldDescriptor ProtobufCFieldDescriptor;
+typedef struct ProtobufCIntRange ProtobufCIntRange;
+typedef struct ProtobufCMessage ProtobufCMessage;
+typedef struct ProtobufCMessageDescriptor ProtobufCMessageDescriptor;
+typedef struct ProtobufCMessageUnknownField ProtobufCMessageUnknownField;
+typedef struct ProtobufCMethodDescriptor ProtobufCMethodDescriptor;
+typedef struct ProtobufCService ProtobufCService;
+typedef struct ProtobufCServiceDescriptor ProtobufCServiceDescriptor;
+
+/** Boolean type. */
+typedef int protobuf_c_boolean;
+
+typedef void (*ProtobufCClosure)(const ProtobufCMessage *, void *closure_data);
+typedef void (*ProtobufCMessageInit)(ProtobufCMessage *);
+typedef void (*ProtobufCServiceDestroy)(ProtobufCService *);
+
+/**
+ * Structure for defining a custom memory allocator.
+ */
+struct ProtobufCAllocator {
+	/** Function to allocate memory. */
+	void		*(*alloc)(void *allocator_data, size_t size);
+
+	/** Function to free memory. */
+	void		(*free)(void *allocator_data, void *pointer);
+
+	/** Opaque pointer passed to `alloc` and `free` functions. */
+	void		*allocator_data;
+};
+
+/**
+ * Structure for the protobuf `bytes` scalar type.
+ *
+ * The data contained in a `ProtobufCBinaryData` is an arbitrary sequence of
+ * bytes. It may contain embedded `NUL` characters and is not required to be
+ * `NUL`-terminated.
+ */
+struct ProtobufCBinaryData {
+	size_t	len;        /**< Number of bytes in the `data` field. */
+	uint8_t	*data;      /**< Data bytes. */
+};
+
+/**
+ * Structure for defining a virtual append-only buffer. Used by
+ * protobuf_c_message_pack_to_buffer() to abstract the consumption of serialized
+ * bytes.
+ *
+ * `ProtobufCBuffer` "subclasses" may be defined on the stack. For example, to
+ * write to a `FILE` object:
+ *
+~~~{.c}
+typedef struct {
+        ProtobufCBuffer base;
+        FILE *fp;
+} BufferAppendToFile;
+
+static void
+my_buffer_file_append(ProtobufCBuffer *buffer,
+                      size_t len,
+                      const uint8_t *data)
+{
+        BufferAppendToFile *file_buf = (BufferAppendToFile *) buffer;
+        fwrite(data, len, 1, file_buf->fp); // XXX: No error handling!
+}
+~~~
+ *
+ * To use this new type of ProtobufCBuffer, it could be called as follows:
+ *
+~~~{.c}
+...
+BufferAppendToFile tmp = {0};
+tmp.base.append = my_buffer_file_append;
+tmp.fp = fp;
+protobuf_c_message_pack_to_buffer(&message, &tmp);
+...
+~~~
+ */
+struct ProtobufCBuffer {
+	/** Append function. Consumes the `len` bytes stored at `data`. */
+	void		(*append)(ProtobufCBuffer *buffer,
+				  size_t len,
+				  const uint8_t *data);
+};
+
+/**
+ * Simple buffer "subclass" of `ProtobufCBuffer`.
+ *
+ * A `ProtobufCBufferSimple` object is declared on the stack and uses a
+ * scratch buffer provided by the user for the initial allocation. It performs
+ * exponential resizing, using dynamically allocated memory. A
+ * `ProtobufCBufferSimple` object can be created and used as follows:
+ *
+~~~{.c}
+uint8_t pad[128];
+ProtobufCBufferSimple simple = PROTOBUF_C_BUFFER_SIMPLE_INIT(pad);
+ProtobufCBuffer *buffer = (ProtobufCBuffer *) &simple;
+~~~
+ *
+ * `buffer` can now be used with `protobuf_c_message_pack_to_buffer()`. Once a
+ * message has been serialized to a `ProtobufCBufferSimple` object, the
+ * serialized data bytes can be accessed from the `.data` field.
+ *
+ * To free the memory allocated by a `ProtobufCBufferSimple` object, if any,
+ * call PROTOBUF_C_BUFFER_SIMPLE_CLEAR() on the object, for example:
+ *
+~~~{.c}
+PROTOBUF_C_BUFFER_SIMPLE_CLEAR(&simple);
+~~~
+ *
+ * \see PROTOBUF_C_BUFFER_SIMPLE_INIT
+ * \see PROTOBUF_C_BUFFER_SIMPLE_CLEAR
+ */
+struct ProtobufCBufferSimple {
+	/** "Base class". */
+	ProtobufCBuffer		base;
+	/** Number of bytes allocated in `data`. */
+	size_t			alloced;
+	/** Number of bytes currently stored in `data`. */
+	size_t			len;
+	/** Data bytes. */
+	uint8_t			*data;
+	/** Whether `data` must be freed. */
+	protobuf_c_boolean	must_free_data;
+	/** Allocator to use. May be NULL to indicate the system allocator. */
+	ProtobufCAllocator	*allocator;
+};
+
+/**
+ * Describes an enumeration as a whole, with all of its values.
+ */
+struct ProtobufCEnumDescriptor {
+	/** Magic value checked to ensure that the API is used correctly. */
+	uint32_t			magic;
+
+	/** The qualified name (e.g., "namespace.Type"). */
+	const char			*name;
+	/** The unqualified name as given in the .proto file (e.g., "Type"). */
+	const char			*short_name;
+	/** Identifier used in generated C code. */
+	const char			*c_name;
+	/** The dot-separated namespace. */
+	const char			*package_name;
+
+	/** Number elements in `values`. */
+	unsigned			n_values;
+	/** Array of distinct values, sorted by numeric value. */
+	const ProtobufCEnumValue	*values;
+
+	/** Number of elements in `values_by_name`. */
+	unsigned			n_value_names;
+	/** Array of named values, including aliases, sorted by name. */
+	const ProtobufCEnumValueIndex	*values_by_name;
+
+	/** Number of elements in `value_ranges`. */
+	unsigned			n_value_ranges;
+	/** Value ranges, for faster lookups by numeric value. */
+	const ProtobufCIntRange		*value_ranges;
+
+	/** Reserved for future use. */
+	void				*reserved1;
+	/** Reserved for future use. */
+	void				*reserved2;
+	/** Reserved for future use. */
+	void				*reserved3;
+	/** Reserved for future use. */
+	void				*reserved4;
+};
+
+/**
+ * Represents a single value of an enumeration.
+ */
+struct ProtobufCEnumValue {
+	/** The string identifying this value in the .proto file. */
+	const char	*name;
+
+	/** The string identifying this value in generated C code. */
+	const char	*c_name;
+
+	/** The numeric value assigned in the .proto file. */
+	int		value;
+};
+
+/**
+ * Used by `ProtobufCEnumDescriptor` to look up enum values.
+ */
+struct ProtobufCEnumValueIndex {
+	/** Name of the enum value. */
+	const char      *name;
+	/** Index into values[] array. */
+	unsigned        index;
+};
+
+/**
+ * Describes a single field in a message.
+ */
+struct ProtobufCFieldDescriptor {
+	/** Name of the field as given in the .proto file. */
+	const char		*name;
+
+	/** Tag value of the field as given in the .proto file. */
+	uint32_t		id;
+
+	/** Whether the field is `REQUIRED`, `OPTIONAL`, or `REPEATED`. */
+	ProtobufCLabel		label;
+
+	/** The type of the field. */
+	ProtobufCType		type;
+
+	/**
+	 * The offset in bytes of the message's C structure's quantifier field
+	 * (the `has_MEMBER` field for optional members or the `n_MEMBER` field
+	 * for repeated members or the case enum for oneofs).
+	 */
+	unsigned		quantifier_offset;
+
+	/**
+	 * The offset in bytes into the message's C structure for the member
+	 * itself.
+	 */
+	unsigned		offset;
+
+	/**
+	 * A type-specific descriptor.
+	 *
+	 * If `type` is `PROTOBUF_C_TYPE_ENUM`, then `descriptor` points to the
+	 * corresponding `ProtobufCEnumDescriptor`.
+	 *
+	 * If `type` is `PROTOBUF_C_TYPE_MESSAGE`, then `descriptor` points to
+	 * the corresponding `ProtobufCMessageDescriptor`.
+	 *
+	 * Otherwise this field is NULL.
+	 */
+	const void		*descriptor; /* for MESSAGE and ENUM types */
+
+	/** The default value for this field, if defined. May be NULL. */
+	const void		*default_value;
+
+	/**
+	 * A flag word. Zero or more of the bits defined in the
+	 * `ProtobufCFieldFlag` enum may be set.
+	 */
+	uint32_t		flags;
+
+	/** Reserved for future use. */
+	unsigned		reserved_flags;
+	/** Reserved for future use. */
+	void			*reserved2;
+	/** Reserved for future use. */
+	void			*reserved3;
+};
+
+/**
+ * Helper structure for optimizing int => index lookups in the case
+ * where the keys are mostly consecutive values, as they presumably are for
+ * enums and fields.
+ *
+ * The data structures requires that the values in the original array are
+ * sorted.
+ */
+struct ProtobufCIntRange {
+	int             start_value;
+	unsigned        orig_index;
+	/*
+	 * NOTE: the number of values in the range can be inferred by looking
+	 * at the next element's orig_index. A dummy element is added to make
+	 * this simple.
+	 */
+};
+
+/**
+ * An instance of a message.
+ *
+ * `ProtobufCMessage` is a light-weight "base class" for all messages.
+ *
+ * In particular, `ProtobufCMessage` doesn't have any allocation policy
+ * associated with it. That's because it's common to create `ProtobufCMessage`
+ * objects on the stack. In fact, that's what we recommend for sending messages.
+ * If the object is allocated from the stack, you can't really have a memory
+ * leak.
+ *
+ * This means that calls to functions like protobuf_c_message_unpack() which
+ * return a `ProtobufCMessage` must be paired with a call to a free function,
+ * like protobuf_c_message_free_unpacked().
+ */
+struct ProtobufCMessage {
+	/** The descriptor for this message type. */
+	const ProtobufCMessageDescriptor	*descriptor;
+	/** The number of elements in `unknown_fields`. */
+	unsigned				n_unknown_fields;
+	/** The fields that weren't recognized by the parser. */
+	ProtobufCMessageUnknownField		*unknown_fields;
+};
+
+/**
+ * Describes a message.
+ */
+struct ProtobufCMessageDescriptor {
+	/** Magic value checked to ensure that the API is used correctly. */
+	uint32_t			magic;
+
+	/** The qualified name (e.g., "namespace.Type"). */
+	const char			*name;
+	/** The unqualified name as given in the .proto file (e.g., "Type"). */
+	const char			*short_name;
+	/** Identifier used in generated C code. */
+	const char			*c_name;
+	/** The dot-separated namespace. */
+	const char			*package_name;
+
+	/**
+	 * Size in bytes of the C structure representing an instance of this
+	 * type of message.
+	 */
+	size_t				sizeof_message;
+
+	/** Number of elements in `fields`. */
+	unsigned			n_fields;
+	/** Field descriptors, sorted by tag number. */
+	const ProtobufCFieldDescriptor	*fields;
+	/** Used for looking up fields by name. */
+	const unsigned			*fields_sorted_by_name;
+
+	/** Number of elements in `field_ranges`. */
+	unsigned			n_field_ranges;
+	/** Used for looking up fields by id. */
+	const ProtobufCIntRange		*field_ranges;
+
+	/** Message initialisation function. */
+	ProtobufCMessageInit		message_init;
+
+	/** Reserved for future use. */
+	void				*reserved1;
+	/** Reserved for future use. */
+	void				*reserved2;
+	/** Reserved for future use. */
+	void				*reserved3;
+};
+
+/**
+ * An unknown message field.
+ */
+struct ProtobufCMessageUnknownField {
+	/** The tag number. */
+	uint32_t		tag;
+	/** The wire type of the field. */
+	ProtobufCWireType	wire_type;
+	/** Number of bytes in `data`. */
+	size_t			len;
+	/** Field data. */
+	uint8_t			*data;
+};
+
+/**
+ * Method descriptor.
+ */
+struct ProtobufCMethodDescriptor {
+	/** Method name. */
+	const char				*name;
+	/** Input message descriptor. */
+	const ProtobufCMessageDescriptor	*input;
+	/** Output message descriptor. */
+	const ProtobufCMessageDescriptor	*output;
+};
+
+/**
+ * Service.
+ */
+struct ProtobufCService {
+	/** Service descriptor. */
+	const ProtobufCServiceDescriptor *descriptor;
+	/** Function to invoke the service. */
+	void (*invoke)(ProtobufCService *service,
+		       unsigned method_index,
+		       const ProtobufCMessage *input,
+		       ProtobufCClosure closure,
+		       void *closure_data);
+	/** Function to destroy the service. */
+	void (*destroy)(ProtobufCService *service);
+};
+
+/**
+ * Service descriptor.
+ */
+struct ProtobufCServiceDescriptor {
+	/** Magic value checked to ensure that the API is used correctly. */
+	uint32_t			magic;
+
+	/** Service name. */
+	const char			*name;
+	/** Short version of service name. */
+	const char			*short_name;
+	/** C identifier for the service name. */
+	const char			*c_name;
+	/** Package name. */
+	const char			*package;
+	/** Number of elements in `methods`. */
+	unsigned			n_methods;
+	/** Method descriptors, in the order defined in the .proto file. */
+	const ProtobufCMethodDescriptor	*methods;
+	/** Sort index of methods. */
+	const unsigned			*method_indices_by_name;
+};
+
+/**
+ * Get the version of the protobuf-c library. Note that this is the version of
+ * the library linked against, not the version of the headers compiled against.
+ *
+ * \return A string containing the version number of protobuf-c.
+ */
+PROTOBUF_C__API
+const char *
+protobuf_c_version(void);
+
+/**
+ * Get the version of the protobuf-c library. Note that this is the version of
+ * the library linked against, not the version of the headers compiled against.
+ *
+ * \return A 32 bit unsigned integer containing the version number of
+ *      protobuf-c, represented in base-10 as (MAJOR*1E6) + (MINOR*1E3) + PATCH.
+ */
+PROTOBUF_C__API
+uint32_t
+protobuf_c_version_number(void);
+
+/**
+ * The version of the protobuf-c headers, represented as a string using the same
+ * format as protobuf_c_version().
+ */
+#define PROTOBUF_C_VERSION		"1.4.1"
+
+/**
+ * The version of the protobuf-c headers, represented as an integer using the
+ * same format as protobuf_c_version_number().
+ */
+#define PROTOBUF_C_VERSION_NUMBER	1004001
+
+/**
+ * The minimum protoc-c version which works with the current version of the
+ * protobuf-c headers.
+ */
+#define PROTOBUF_C_MIN_COMPILER_VERSION	1000000
+
+/**
+ * Look up a `ProtobufCEnumValue` from a `ProtobufCEnumDescriptor` by name.
+ *
+ * \param desc
+ *      The `ProtobufCEnumDescriptor` object.
+ * \param name
+ *      The `name` field from the corresponding `ProtobufCEnumValue` object to
+ *      match.
+ * \return
+ *      A `ProtobufCEnumValue` object.
+ * \retval NULL
+ *      If not found or if the optimize_for = CODE_SIZE option was set.
+ */
+PROTOBUF_C__API
+const ProtobufCEnumValue *
+protobuf_c_enum_descriptor_get_value_by_name(
+	const ProtobufCEnumDescriptor *desc,
+	const char *name);
+
+/**
+ * Look up a `ProtobufCEnumValue` from a `ProtobufCEnumDescriptor` by numeric
+ * value.
+ *
+ * \param desc
+ *      The `ProtobufCEnumDescriptor` object.
+ * \param value
+ *      The `value` field from the corresponding `ProtobufCEnumValue` object to
+ *      match.
+ *
+ * \return
+ *      A `ProtobufCEnumValue` object.
+ * \retval NULL
+ *      If not found.
+ */
+PROTOBUF_C__API
+const ProtobufCEnumValue *
+protobuf_c_enum_descriptor_get_value(
+	const ProtobufCEnumDescriptor *desc,
+	int value);
+
+/**
+ * Look up a `ProtobufCFieldDescriptor` from a `ProtobufCMessageDescriptor` by
+ * the name of the field.
+ *
+ * \param desc
+ *      The `ProtobufCMessageDescriptor` object.
+ * \param name
+ *      The name of the field.
+ * \return
+ *      A `ProtobufCFieldDescriptor` object.
+ * \retval NULL
+ *      If not found or if the optimize_for = CODE_SIZE option was set.
+ */
+PROTOBUF_C__API
+const ProtobufCFieldDescriptor *
+protobuf_c_message_descriptor_get_field_by_name(
+	const ProtobufCMessageDescriptor *desc,
+	const char *name);
+
+/**
+ * Look up a `ProtobufCFieldDescriptor` from a `ProtobufCMessageDescriptor` by
+ * the tag value of the field.
+ *
+ * \param desc
+ *      The `ProtobufCMessageDescriptor` object.
+ * \param value
+ *      The tag value of the field.
+ * \return
+ *      A `ProtobufCFieldDescriptor` object.
+ * \retval NULL
+ *      If not found.
+ */
+PROTOBUF_C__API
+const ProtobufCFieldDescriptor *
+protobuf_c_message_descriptor_get_field(
+	const ProtobufCMessageDescriptor *desc,
+	unsigned value);
+
+/**
+ * Determine the number of bytes required to store the serialised message.
+ *
+ * \param message
+ *      The message object to serialise.
+ * \return
+ *      Number of bytes.
+ */
+PROTOBUF_C__API
+size_t
+protobuf_c_message_get_packed_size(const ProtobufCMessage *message);
+
+/**
+ * Serialise a message from its in-memory representation.
+ *
+ * This function stores the serialised bytes of the message in a pre-allocated
+ * buffer.
+ *
+ * \param message
+ *      The message object to serialise.
+ * \param[out] out
+ *      Buffer to store the bytes of the serialised message. This buffer must
+ *      have enough space to store the packed message. Use
+ *      protobuf_c_message_get_packed_size() to determine the number of bytes
+ *      required.
+ * \return
+ *      Number of bytes stored in `out`.
+ */
+PROTOBUF_C__API
+size_t
+protobuf_c_message_pack(const ProtobufCMessage *message, uint8_t *out);
+
+/**
+ * Serialise a message from its in-memory representation to a virtual buffer.
+ *
+ * This function calls the `append` method of a `ProtobufCBuffer` object to
+ * consume the bytes generated by the serialiser.
+ *
+ * \param message
+ *      The message object to serialise.
+ * \param buffer
+ *      The virtual buffer object.
+ * \return
+ *      Number of bytes passed to the virtual buffer.
+ */
+PROTOBUF_C__API
+size_t
+protobuf_c_message_pack_to_buffer(
+	const ProtobufCMessage *message,
+	ProtobufCBuffer *buffer);
+
+/**
+ * Unpack a serialised message into an in-memory representation.
+ *
+ * \param descriptor
+ *      The message descriptor.
+ * \param allocator
+ *      `ProtobufCAllocator` to use for memory allocation. May be NULL to
+ *      specify the default allocator.
+ * \param len
+ *      Length in bytes of the serialised message.
+ * \param data
+ *      Pointer to the serialised message.
+ * \return
+ *      An unpacked message object.
+ * \retval NULL
+ *      If an error occurred during unpacking.
+ */
+PROTOBUF_C__API
+ProtobufCMessage *
+protobuf_c_message_unpack(
+	const ProtobufCMessageDescriptor *descriptor,
+	ProtobufCAllocator *allocator,
+	size_t len,
+	const uint8_t *data);
+
+/**
+ * Free an unpacked message object.
+ *
+ * This function should be used to deallocate the memory used by a call to
+ * protobuf_c_message_unpack().
+ *
+ * \param message
+ *      The message object to free. May be NULL.
+ * \param allocator
+ *      `ProtobufCAllocator` to use for memory deallocation. May be NULL to
+ *      specify the default allocator.
+ */
+PROTOBUF_C__API
+void
+protobuf_c_message_free_unpacked(
+	ProtobufCMessage *message,
+	ProtobufCAllocator *allocator);
+
+/**
+ * Check the validity of a message object.
+ *
+ * Makes sure all required fields (`PROTOBUF_C_LABEL_REQUIRED`) are present.
+ * Recursively checks nested messages.
+ *
+ * \retval TRUE
+ *      Message is valid.
+ * \retval FALSE
+ *      Message is invalid.
+ */
+PROTOBUF_C__API
+protobuf_c_boolean
+protobuf_c_message_check(const ProtobufCMessage *);
+
+/** Message initialiser. */
+#define PROTOBUF_C_MESSAGE_INIT(descriptor) { descriptor, 0, NULL }
+
+/**
+ * Initialise a message object from a message descriptor.
+ *
+ * \param descriptor
+ *      Message descriptor.
+ * \param message
+ *      Allocated block of memory of size `descriptor->sizeof_message`.
+ */
+PROTOBUF_C__API
+void
+protobuf_c_message_init(
+	const ProtobufCMessageDescriptor *descriptor,
+	void *message);
+
+/**
+ * Free a service.
+ *
+ * \param service
+ *      The service object to free.
+ */
+PROTOBUF_C__API
+void
+protobuf_c_service_destroy(ProtobufCService *service);
+
+/**
+ * Look up a `ProtobufCMethodDescriptor` by name.
+ *
+ * \param desc
+ *      Service descriptor.
+ * \param name
+ *      Name of the method.
+ *
+ * \return
+ *      A `ProtobufCMethodDescriptor` object.
+ * \retval NULL
+ *      If not found or if the optimize_for = CODE_SIZE option was set.
+ */
+PROTOBUF_C__API
+const ProtobufCMethodDescriptor *
+protobuf_c_service_descriptor_get_method_by_name(
+	const ProtobufCServiceDescriptor *desc,
+	const char *name);
+
+/**
+ * Initialise a `ProtobufCBufferSimple` object.
+ */
+#define PROTOBUF_C_BUFFER_SIMPLE_INIT(array_of_bytes)                   \
+{                                                                       \
+	{ protobuf_c_buffer_simple_append },                            \
+	sizeof(array_of_bytes),                                         \
+	0,                                                              \
+	(array_of_bytes),                                               \
+	0,                                                              \
+	NULL                                                            \
+}
+
+/**
+ * Clear a `ProtobufCBufferSimple` object, freeing any allocated memory.
+ */
+#define PROTOBUF_C_BUFFER_SIMPLE_CLEAR(simp_buf)                        \
+do {                                                                    \
+	if ((simp_buf)->must_free_data) {                               \
+		if ((simp_buf)->allocator != NULL)                      \
+			(simp_buf)->allocator->free(                    \
+				(simp_buf)->allocator,                  \
+				(simp_buf)->data);			\
+		else                                                    \
+			free((simp_buf)->data);                         \
+	}                                                               \
+} while (0)
+
+/**
+ * The `append` method for `ProtobufCBufferSimple`.
+ *
+ * \param buffer
+ *      The buffer object to append to. Must actually be a
+ *      `ProtobufCBufferSimple` object.
+ * \param len
+ *      Number of bytes in `data`.
+ * \param data
+ *      Data to append.
+ */
+PROTOBUF_C__API
+void
+protobuf_c_buffer_simple_append(
+	ProtobufCBuffer *buffer,
+	size_t len,
+	const unsigned char *data);
+
+PROTOBUF_C__API
+void
+protobuf_c_service_generated_init(
+	ProtobufCService *service,
+	const ProtobufCServiceDescriptor *descriptor,
+	ProtobufCServiceDestroy destroy);
+
+PROTOBUF_C__API
+void
+protobuf_c_service_invoke_internal(
+	ProtobufCService *service,
+	unsigned method_index,
+	const ProtobufCMessage *input,
+	ProtobufCClosure closure,
+	void *closure_data);
+
+/**@}*/
+
+PROTOBUF_C__END_DECLS
+
+#ifdef __cplusplus
+extern "C" void message_init_generic(const ProtobufCMessageDescriptor * desc, ProtobufCMessage * message);
+
+struct ProtobufCppMessage : public ProtobufCMessage
+{
+	ProtobufCppMessage(const ProtobufCMessageDescriptor &descr)
+	{
+		message_init_generic(&descr, this);
+	}
+};
+#endif
+
+#endif /* PROTOBUF_C_H */
diff --git a/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.pb-c.cpp b/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.pb-c.cpp
new file mode 100644
index 0000000000..97245861d5
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.pb-c.cpp
@@ -0,0 +1,5024 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_auth.steamclient.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "steammessages_auth.steamclient.pb-c.h"
+size_t cauthentication__get_password_rsapublic_key__request__get_packed_size
+                     (const CAuthenticationGetPasswordRSAPublicKeyRequest *message)
+{
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__get_password_rsapublic_key__request__pack
+                     (const CAuthenticationGetPasswordRSAPublicKeyRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__get_password_rsapublic_key__request__pack_to_buffer
+                     (const CAuthenticationGetPasswordRSAPublicKeyRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationGetPasswordRSAPublicKeyRequest *
+       cauthentication__get_password_rsapublic_key__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationGetPasswordRSAPublicKeyRequest *)
+     protobuf_c_message_unpack (&cauthentication__get_password_rsapublic_key__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__get_password_rsapublic_key__request__free_unpacked
+                     (CAuthenticationGetPasswordRSAPublicKeyRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__get_password_rsapublic_key__response__get_packed_size
+                     (const CAuthenticationGetPasswordRSAPublicKeyResponse *message)
+{
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__get_password_rsapublic_key__response__pack
+                     (const CAuthenticationGetPasswordRSAPublicKeyResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__get_password_rsapublic_key__response__pack_to_buffer
+                     (const CAuthenticationGetPasswordRSAPublicKeyResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationGetPasswordRSAPublicKeyResponse *
+       cauthentication__get_password_rsapublic_key__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationGetPasswordRSAPublicKeyResponse *)
+     protobuf_c_message_unpack (&cauthentication__get_password_rsapublic_key__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__get_password_rsapublic_key__response__free_unpacked
+                     (CAuthenticationGetPasswordRSAPublicKeyResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__get_password_rsapublic_key__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__device_details__get_packed_size
+                     (const CAuthenticationDeviceDetails *message)
+{
+  assert(message->descriptor == &cauthentication__device_details__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__device_details__pack
+                     (const CAuthenticationDeviceDetails *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__device_details__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__device_details__pack_to_buffer
+                     (const CAuthenticationDeviceDetails *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__device_details__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationDeviceDetails *
+       cauthentication__device_details__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationDeviceDetails *)
+     protobuf_c_message_unpack (&cauthentication__device_details__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__device_details__free_unpacked
+                     (CAuthenticationDeviceDetails *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__device_details__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__begin_auth_session_via_qr__request__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaQRRequest *message)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__begin_auth_session_via_qr__request__pack
+                     (const CAuthenticationBeginAuthSessionViaQRRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__begin_auth_session_via_qr__request__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaQRRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationBeginAuthSessionViaQRRequest *
+       cauthentication__begin_auth_session_via_qr__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationBeginAuthSessionViaQRRequest *)
+     protobuf_c_message_unpack (&cauthentication__begin_auth_session_via_qr__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__begin_auth_session_via_qr__request__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaQRRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__allowed_confirmation__get_packed_size
+                     (const CAuthenticationAllowedConfirmation *message)
+{
+  assert(message->descriptor == &cauthentication__allowed_confirmation__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__allowed_confirmation__pack
+                     (const CAuthenticationAllowedConfirmation *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__allowed_confirmation__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__allowed_confirmation__pack_to_buffer
+                     (const CAuthenticationAllowedConfirmation *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__allowed_confirmation__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationAllowedConfirmation *
+       cauthentication__allowed_confirmation__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationAllowedConfirmation *)
+     protobuf_c_message_unpack (&cauthentication__allowed_confirmation__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__allowed_confirmation__free_unpacked
+                     (CAuthenticationAllowedConfirmation *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__allowed_confirmation__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__begin_auth_session_via_qr__response__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaQRResponse *message)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__begin_auth_session_via_qr__response__pack
+                     (const CAuthenticationBeginAuthSessionViaQRResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__begin_auth_session_via_qr__response__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaQRResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationBeginAuthSessionViaQRResponse *
+       cauthentication__begin_auth_session_via_qr__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationBeginAuthSessionViaQRResponse *)
+     protobuf_c_message_unpack (&cauthentication__begin_auth_session_via_qr__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__begin_auth_session_via_qr__response__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaQRResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_qr__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__begin_auth_session_via_credentials__request__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaCredentialsRequest *message)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__begin_auth_session_via_credentials__request__pack
+                     (const CAuthenticationBeginAuthSessionViaCredentialsRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__begin_auth_session_via_credentials__request__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaCredentialsRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationBeginAuthSessionViaCredentialsRequest *
+       cauthentication__begin_auth_session_via_credentials__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationBeginAuthSessionViaCredentialsRequest *)
+     protobuf_c_message_unpack (&cauthentication__begin_auth_session_via_credentials__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__begin_auth_session_via_credentials__request__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaCredentialsRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__begin_auth_session_via_credentials__response__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaCredentialsResponse *message)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__begin_auth_session_via_credentials__response__pack
+                     (const CAuthenticationBeginAuthSessionViaCredentialsResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__begin_auth_session_via_credentials__response__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaCredentialsResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationBeginAuthSessionViaCredentialsResponse *
+       cauthentication__begin_auth_session_via_credentials__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationBeginAuthSessionViaCredentialsResponse *)
+     protobuf_c_message_unpack (&cauthentication__begin_auth_session_via_credentials__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__begin_auth_session_via_credentials__response__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaCredentialsResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__begin_auth_session_via_credentials__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__poll_auth_session_status__request__get_packed_size
+                     (const CAuthenticationPollAuthSessionStatusRequest *message)
+{
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__poll_auth_session_status__request__pack
+                     (const CAuthenticationPollAuthSessionStatusRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__poll_auth_session_status__request__pack_to_buffer
+                     (const CAuthenticationPollAuthSessionStatusRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationPollAuthSessionStatusRequest *
+       cauthentication__poll_auth_session_status__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationPollAuthSessionStatusRequest *)
+     protobuf_c_message_unpack (&cauthentication__poll_auth_session_status__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__poll_auth_session_status__request__free_unpacked
+                     (CAuthenticationPollAuthSessionStatusRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__poll_auth_session_status__response__get_packed_size
+                     (const CAuthenticationPollAuthSessionStatusResponse *message)
+{
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__poll_auth_session_status__response__pack
+                     (const CAuthenticationPollAuthSessionStatusResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__poll_auth_session_status__response__pack_to_buffer
+                     (const CAuthenticationPollAuthSessionStatusResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationPollAuthSessionStatusResponse *
+       cauthentication__poll_auth_session_status__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationPollAuthSessionStatusResponse *)
+     protobuf_c_message_unpack (&cauthentication__poll_auth_session_status__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__poll_auth_session_status__response__free_unpacked
+                     (CAuthenticationPollAuthSessionStatusResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__poll_auth_session_status__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__get_auth_session_info__request__get_packed_size
+                     (const CAuthenticationGetAuthSessionInfoRequest *message)
+{
+  assert(message->descriptor == &cauthentication__get_auth_session_info__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__get_auth_session_info__request__pack
+                     (const CAuthenticationGetAuthSessionInfoRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__get_auth_session_info__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__get_auth_session_info__request__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionInfoRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__get_auth_session_info__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationGetAuthSessionInfoRequest *
+       cauthentication__get_auth_session_info__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationGetAuthSessionInfoRequest *)
+     protobuf_c_message_unpack (&cauthentication__get_auth_session_info__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__get_auth_session_info__request__free_unpacked
+                     (CAuthenticationGetAuthSessionInfoRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__get_auth_session_info__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__get_auth_session_info__response__get_packed_size
+                     (const CAuthenticationGetAuthSessionInfoResponse *message)
+{
+  assert(message->descriptor == &cauthentication__get_auth_session_info__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__get_auth_session_info__response__pack
+                     (const CAuthenticationGetAuthSessionInfoResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__get_auth_session_info__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__get_auth_session_info__response__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionInfoResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__get_auth_session_info__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationGetAuthSessionInfoResponse *
+       cauthentication__get_auth_session_info__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationGetAuthSessionInfoResponse *)
+     protobuf_c_message_unpack (&cauthentication__get_auth_session_info__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__get_auth_session_info__response__free_unpacked
+                     (CAuthenticationGetAuthSessionInfoResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__get_auth_session_info__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__update_auth_session_with_mobile_confirmation__request__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *message)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__update_auth_session_with_mobile_confirmation__request__pack
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__update_auth_session_with_mobile_confirmation__request__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *
+       cauthentication__update_auth_session_with_mobile_confirmation__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *)
+     protobuf_c_message_unpack (&cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__update_auth_session_with_mobile_confirmation__request__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__update_auth_session_with_mobile_confirmation__response__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *message)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__update_auth_session_with_mobile_confirmation__response__pack
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__update_auth_session_with_mobile_confirmation__response__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *
+       cauthentication__update_auth_session_with_mobile_confirmation__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *)
+     protobuf_c_message_unpack (&cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__update_auth_session_with_mobile_confirmation__response__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__update_auth_session_with_steam_guard_code__request__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *message)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__update_auth_session_with_steam_guard_code__request__pack
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__update_auth_session_with_steam_guard_code__request__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *
+       cauthentication__update_auth_session_with_steam_guard_code__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *)
+     protobuf_c_message_unpack (&cauthentication__update_auth_session_with_steam_guard_code__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__update_auth_session_with_steam_guard_code__request__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__update_auth_session_with_steam_guard_code__response__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *message)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__update_auth_session_with_steam_guard_code__response__pack
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__update_auth_session_with_steam_guard_code__response__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *
+       cauthentication__update_auth_session_with_steam_guard_code__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *)
+     protobuf_c_message_unpack (&cauthentication__update_auth_session_with_steam_guard_code__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__update_auth_session_with_steam_guard_code__response__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__update_auth_session_with_steam_guard_code__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__access_token__generate_for_app__request__get_packed_size
+                     (const CAuthenticationAccessTokenGenerateForAppRequest *message)
+{
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__access_token__generate_for_app__request__pack
+                     (const CAuthenticationAccessTokenGenerateForAppRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__access_token__generate_for_app__request__pack_to_buffer
+                     (const CAuthenticationAccessTokenGenerateForAppRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationAccessTokenGenerateForAppRequest *
+       cauthentication__access_token__generate_for_app__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationAccessTokenGenerateForAppRequest *)
+     protobuf_c_message_unpack (&cauthentication__access_token__generate_for_app__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__access_token__generate_for_app__request__free_unpacked
+                     (CAuthenticationAccessTokenGenerateForAppRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__access_token__generate_for_app__response__get_packed_size
+                     (const CAuthenticationAccessTokenGenerateForAppResponse *message)
+{
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__access_token__generate_for_app__response__pack
+                     (const CAuthenticationAccessTokenGenerateForAppResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__access_token__generate_for_app__response__pack_to_buffer
+                     (const CAuthenticationAccessTokenGenerateForAppResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationAccessTokenGenerateForAppResponse *
+       cauthentication__access_token__generate_for_app__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationAccessTokenGenerateForAppResponse *)
+     protobuf_c_message_unpack (&cauthentication__access_token__generate_for_app__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__access_token__generate_for_app__response__free_unpacked
+                     (CAuthenticationAccessTokenGenerateForAppResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__access_token__generate_for_app__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__refresh_token__enumerate__request__get_packed_size
+                     (const CAuthenticationRefreshTokenEnumerateRequest *message)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__refresh_token__enumerate__request__pack
+                     (const CAuthenticationRefreshTokenEnumerateRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__refresh_token__enumerate__request__pack_to_buffer
+                     (const CAuthenticationRefreshTokenEnumerateRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationRefreshTokenEnumerateRequest *
+       cauthentication__refresh_token__enumerate__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationRefreshTokenEnumerateRequest *)
+     protobuf_c_message_unpack (&cauthentication__refresh_token__enumerate__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__refresh_token__enumerate__request__free_unpacked
+                     (CAuthenticationRefreshTokenEnumerateRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__refresh_token__enumerate__response__get_packed_size
+                     (const CAuthenticationRefreshTokenEnumerateResponse *message)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__refresh_token__enumerate__response__pack
+                     (const CAuthenticationRefreshTokenEnumerateResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__refresh_token__enumerate__response__pack_to_buffer
+                     (const CAuthenticationRefreshTokenEnumerateResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationRefreshTokenEnumerateResponse *
+       cauthentication__refresh_token__enumerate__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationRefreshTokenEnumerateResponse *)
+     protobuf_c_message_unpack (&cauthentication__refresh_token__enumerate__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__refresh_token__enumerate__response__free_unpacked
+                     (CAuthenticationRefreshTokenEnumerateResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__refresh_token__enumerate__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__get_auth_sessions_for_account__request__get_packed_size
+                     (const CAuthenticationGetAuthSessionsForAccountRequest *message)
+{
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__get_auth_sessions_for_account__request__pack
+                     (const CAuthenticationGetAuthSessionsForAccountRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__get_auth_sessions_for_account__request__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionsForAccountRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationGetAuthSessionsForAccountRequest *
+       cauthentication__get_auth_sessions_for_account__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationGetAuthSessionsForAccountRequest *)
+     protobuf_c_message_unpack (&cauthentication__get_auth_sessions_for_account__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__get_auth_sessions_for_account__request__free_unpacked
+                     (CAuthenticationGetAuthSessionsForAccountRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__get_auth_sessions_for_account__response__get_packed_size
+                     (const CAuthenticationGetAuthSessionsForAccountResponse *message)
+{
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__get_auth_sessions_for_account__response__pack
+                     (const CAuthenticationGetAuthSessionsForAccountResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__get_auth_sessions_for_account__response__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionsForAccountResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationGetAuthSessionsForAccountResponse *
+       cauthentication__get_auth_sessions_for_account__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationGetAuthSessionsForAccountResponse *)
+     protobuf_c_message_unpack (&cauthentication__get_auth_sessions_for_account__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__get_auth_sessions_for_account__response__free_unpacked
+                     (CAuthenticationGetAuthSessionsForAccountResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__get_auth_sessions_for_account__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__migrate_mobile_session__request__get_packed_size
+                     (const CAuthenticationMigrateMobileSessionRequest *message)
+{
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__migrate_mobile_session__request__pack
+                     (const CAuthenticationMigrateMobileSessionRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__migrate_mobile_session__request__pack_to_buffer
+                     (const CAuthenticationMigrateMobileSessionRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationMigrateMobileSessionRequest *
+       cauthentication__migrate_mobile_session__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationMigrateMobileSessionRequest *)
+     protobuf_c_message_unpack (&cauthentication__migrate_mobile_session__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__migrate_mobile_session__request__free_unpacked
+                     (CAuthenticationMigrateMobileSessionRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__migrate_mobile_session__response__get_packed_size
+                     (const CAuthenticationMigrateMobileSessionResponse *message)
+{
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__migrate_mobile_session__response__pack
+                     (const CAuthenticationMigrateMobileSessionResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__migrate_mobile_session__response__pack_to_buffer
+                     (const CAuthenticationMigrateMobileSessionResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationMigrateMobileSessionResponse *
+       cauthentication__migrate_mobile_session__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationMigrateMobileSessionResponse *)
+     protobuf_c_message_unpack (&cauthentication__migrate_mobile_session__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__migrate_mobile_session__response__free_unpacked
+                     (CAuthenticationMigrateMobileSessionResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__migrate_mobile_session__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__refresh_token__revoke__request__get_packed_size
+                     (const CAuthenticationRefreshTokenRevokeRequest *message)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__refresh_token__revoke__request__pack
+                     (const CAuthenticationRefreshTokenRevokeRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__refresh_token__revoke__request__pack_to_buffer
+                     (const CAuthenticationRefreshTokenRevokeRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationRefreshTokenRevokeRequest *
+       cauthentication__refresh_token__revoke__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationRefreshTokenRevokeRequest *)
+     protobuf_c_message_unpack (&cauthentication__refresh_token__revoke__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__refresh_token__revoke__request__free_unpacked
+                     (CAuthenticationRefreshTokenRevokeRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication__refresh_token__revoke__response__get_packed_size
+                     (const CAuthenticationRefreshTokenRevokeResponse *message)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication__refresh_token__revoke__response__pack
+                     (const CAuthenticationRefreshTokenRevokeResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication__refresh_token__revoke__response__pack_to_buffer
+                     (const CAuthenticationRefreshTokenRevokeResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationRefreshTokenRevokeResponse *
+       cauthentication__refresh_token__revoke__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationRefreshTokenRevokeResponse *)
+     protobuf_c_message_unpack (&cauthentication__refresh_token__revoke__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication__refresh_token__revoke__response__free_unpacked
+                     (CAuthenticationRefreshTokenRevokeResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication__refresh_token__revoke__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__query_refresh_tokens_by_account__request__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountRequest *message)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__query_refresh_tokens_by_account__request__pack
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__query_refresh_tokens_by_account__request__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportQueryRefreshTokensByAccountRequest *
+       cauthentication_support__query_refresh_tokens_by_account__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportQueryRefreshTokensByAccountRequest *)
+     protobuf_c_message_unpack (&cauthentication_support__query_refresh_tokens_by_account__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__query_refresh_tokens_by_account__request__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokensByAccountRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t csupport_refresh_token_description__get_packed_size
+                     (const CSupportRefreshTokenDescription *message)
+{
+  assert(message->descriptor == &csupport_refresh_token_description__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t csupport_refresh_token_description__pack
+                     (const CSupportRefreshTokenDescription *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &csupport_refresh_token_description__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t csupport_refresh_token_description__pack_to_buffer
+                     (const CSupportRefreshTokenDescription *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &csupport_refresh_token_description__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CSupportRefreshTokenDescription *
+       csupport_refresh_token_description__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CSupportRefreshTokenDescription *)
+     protobuf_c_message_unpack (&csupport_refresh_token_description__descriptor,
+                                allocator, len, data);
+}
+void   csupport_refresh_token_description__free_unpacked
+                     (CSupportRefreshTokenDescription *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &csupport_refresh_token_description__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__query_refresh_tokens_by_account__response__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountResponse *message)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__query_refresh_tokens_by_account__response__pack
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__query_refresh_tokens_by_account__response__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportQueryRefreshTokensByAccountResponse *
+       cauthentication_support__query_refresh_tokens_by_account__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportQueryRefreshTokensByAccountResponse *)
+     protobuf_c_message_unpack (&cauthentication_support__query_refresh_tokens_by_account__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__query_refresh_tokens_by_account__response__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokensByAccountResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__query_refresh_tokens_by_account__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__query_refresh_token_by_id__request__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokenByIDRequest *message)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__query_refresh_token_by_id__request__pack
+                     (const CAuthenticationSupportQueryRefreshTokenByIDRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__query_refresh_token_by_id__request__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokenByIDRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportQueryRefreshTokenByIDRequest *
+       cauthentication_support__query_refresh_token_by_id__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportQueryRefreshTokenByIDRequest *)
+     protobuf_c_message_unpack (&cauthentication_support__query_refresh_token_by_id__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__query_refresh_token_by_id__request__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokenByIDRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__query_refresh_token_by_id__response__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokenByIDResponse *message)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__query_refresh_token_by_id__response__pack
+                     (const CAuthenticationSupportQueryRefreshTokenByIDResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__query_refresh_token_by_id__response__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokenByIDResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportQueryRefreshTokenByIDResponse *
+       cauthentication_support__query_refresh_token_by_id__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportQueryRefreshTokenByIDResponse *)
+     protobuf_c_message_unpack (&cauthentication_support__query_refresh_token_by_id__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__query_refresh_token_by_id__response__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokenByIDResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__query_refresh_token_by_id__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__revoke_token__request__get_packed_size
+                     (const CAuthenticationSupportRevokeTokenRequest *message)
+{
+  assert(message->descriptor == &cauthentication_support__revoke_token__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__revoke_token__request__pack
+                     (const CAuthenticationSupportRevokeTokenRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__revoke_token__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__revoke_token__request__pack_to_buffer
+                     (const CAuthenticationSupportRevokeTokenRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__revoke_token__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportRevokeTokenRequest *
+       cauthentication_support__revoke_token__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportRevokeTokenRequest *)
+     protobuf_c_message_unpack (&cauthentication_support__revoke_token__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__revoke_token__request__free_unpacked
+                     (CAuthenticationSupportRevokeTokenRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__revoke_token__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__revoke_token__response__get_packed_size
+                     (const CAuthenticationSupportRevokeTokenResponse *message)
+{
+  assert(message->descriptor == &cauthentication_support__revoke_token__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__revoke_token__response__pack
+                     (const CAuthenticationSupportRevokeTokenResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__revoke_token__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__revoke_token__response__pack_to_buffer
+                     (const CAuthenticationSupportRevokeTokenResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__revoke_token__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportRevokeTokenResponse *
+       cauthentication_support__revoke_token__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportRevokeTokenResponse *)
+     protobuf_c_message_unpack (&cauthentication_support__revoke_token__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__revoke_token__response__free_unpacked
+                     (CAuthenticationSupportRevokeTokenResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__revoke_token__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__get_token_history__request__get_packed_size
+                     (const CAuthenticationSupportGetTokenHistoryRequest *message)
+{
+  assert(message->descriptor == &cauthentication_support__get_token_history__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__get_token_history__request__pack
+                     (const CAuthenticationSupportGetTokenHistoryRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__get_token_history__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__get_token_history__request__pack_to_buffer
+                     (const CAuthenticationSupportGetTokenHistoryRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__get_token_history__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportGetTokenHistoryRequest *
+       cauthentication_support__get_token_history__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportGetTokenHistoryRequest *)
+     protobuf_c_message_unpack (&cauthentication_support__get_token_history__request__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__get_token_history__request__free_unpacked
+                     (CAuthenticationSupportGetTokenHistoryRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__get_token_history__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t csupport_refresh_token_audit__get_packed_size
+                     (const CSupportRefreshTokenAudit *message)
+{
+  assert(message->descriptor == &csupport_refresh_token_audit__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t csupport_refresh_token_audit__pack
+                     (const CSupportRefreshTokenAudit *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &csupport_refresh_token_audit__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t csupport_refresh_token_audit__pack_to_buffer
+                     (const CSupportRefreshTokenAudit *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &csupport_refresh_token_audit__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CSupportRefreshTokenAudit *
+       csupport_refresh_token_audit__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CSupportRefreshTokenAudit *)
+     protobuf_c_message_unpack (&csupport_refresh_token_audit__descriptor,
+                                allocator, len, data);
+}
+void   csupport_refresh_token_audit__free_unpacked
+                     (CSupportRefreshTokenAudit *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &csupport_refresh_token_audit__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cauthentication_support__get_token_history__response__get_packed_size
+                     (const CAuthenticationSupportGetTokenHistoryResponse *message)
+{
+  assert(message->descriptor == &cauthentication_support__get_token_history__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cauthentication_support__get_token_history__response__pack
+                     (const CAuthenticationSupportGetTokenHistoryResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cauthentication_support__get_token_history__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cauthentication_support__get_token_history__response__pack_to_buffer
+                     (const CAuthenticationSupportGetTokenHistoryResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cauthentication_support__get_token_history__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CAuthenticationSupportGetTokenHistoryResponse *
+       cauthentication_support__get_token_history__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CAuthenticationSupportGetTokenHistoryResponse *)
+     protobuf_c_message_unpack (&cauthentication_support__get_token_history__response__descriptor,
+                                allocator, len, data);
+}
+void   cauthentication_support__get_token_history__response__free_unpacked
+                     (CAuthenticationSupportGetTokenHistoryResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cauthentication_support__get_token_history__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccloud_gaming__create_nonce__request__get_packed_size
+                     (const CCloudGamingCreateNonceRequest *message)
+{
+  assert(message->descriptor == &ccloud_gaming__create_nonce__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccloud_gaming__create_nonce__request__pack
+                     (const CCloudGamingCreateNonceRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccloud_gaming__create_nonce__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccloud_gaming__create_nonce__request__pack_to_buffer
+                     (const CCloudGamingCreateNonceRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccloud_gaming__create_nonce__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCloudGamingCreateNonceRequest *
+       ccloud_gaming__create_nonce__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCloudGamingCreateNonceRequest *)
+     protobuf_c_message_unpack (&ccloud_gaming__create_nonce__request__descriptor,
+                                allocator, len, data);
+}
+void   ccloud_gaming__create_nonce__request__free_unpacked
+                     (CCloudGamingCreateNonceRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccloud_gaming__create_nonce__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccloud_gaming__create_nonce__response__get_packed_size
+                     (const CCloudGamingCreateNonceResponse *message)
+{
+  assert(message->descriptor == &ccloud_gaming__create_nonce__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccloud_gaming__create_nonce__response__pack
+                     (const CCloudGamingCreateNonceResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccloud_gaming__create_nonce__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccloud_gaming__create_nonce__response__pack_to_buffer
+                     (const CCloudGamingCreateNonceResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccloud_gaming__create_nonce__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCloudGamingCreateNonceResponse *
+       ccloud_gaming__create_nonce__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCloudGamingCreateNonceResponse *)
+     protobuf_c_message_unpack (&ccloud_gaming__create_nonce__response__descriptor,
+                                allocator, len, data);
+}
+void   ccloud_gaming__create_nonce__response__free_unpacked
+                     (CCloudGamingCreateNonceResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccloud_gaming__create_nonce__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccloud_gaming__get_time_remaining__request__get_packed_size
+                     (const CCloudGamingGetTimeRemainingRequest *message)
+{
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccloud_gaming__get_time_remaining__request__pack
+                     (const CCloudGamingGetTimeRemainingRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccloud_gaming__get_time_remaining__request__pack_to_buffer
+                     (const CCloudGamingGetTimeRemainingRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCloudGamingGetTimeRemainingRequest *
+       ccloud_gaming__get_time_remaining__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCloudGamingGetTimeRemainingRequest *)
+     protobuf_c_message_unpack (&ccloud_gaming__get_time_remaining__request__descriptor,
+                                allocator, len, data);
+}
+void   ccloud_gaming__get_time_remaining__request__free_unpacked
+                     (CCloudGamingGetTimeRemainingRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccloud_gaming__time_remaining__get_packed_size
+                     (const CCloudGamingTimeRemaining *message)
+{
+  assert(message->descriptor == &ccloud_gaming__time_remaining__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccloud_gaming__time_remaining__pack
+                     (const CCloudGamingTimeRemaining *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccloud_gaming__time_remaining__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccloud_gaming__time_remaining__pack_to_buffer
+                     (const CCloudGamingTimeRemaining *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccloud_gaming__time_remaining__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCloudGamingTimeRemaining *
+       ccloud_gaming__time_remaining__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCloudGamingTimeRemaining *)
+     protobuf_c_message_unpack (&ccloud_gaming__time_remaining__descriptor,
+                                allocator, len, data);
+}
+void   ccloud_gaming__time_remaining__free_unpacked
+                     (CCloudGamingTimeRemaining *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccloud_gaming__time_remaining__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccloud_gaming__get_time_remaining__response__get_packed_size
+                     (const CCloudGamingGetTimeRemainingResponse *message)
+{
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccloud_gaming__get_time_remaining__response__pack
+                     (const CCloudGamingGetTimeRemainingResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccloud_gaming__get_time_remaining__response__pack_to_buffer
+                     (const CCloudGamingGetTimeRemainingResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCloudGamingGetTimeRemainingResponse *
+       ccloud_gaming__get_time_remaining__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCloudGamingGetTimeRemainingResponse *)
+     protobuf_c_message_unpack (&ccloud_gaming__get_time_remaining__response__descriptor,
+                                allocator, len, data);
+}
+void   ccloud_gaming__get_time_remaining__response__free_unpacked
+                     (CCloudGamingGetTimeRemainingResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccloud_gaming__get_time_remaining__response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+static const ProtobufCFieldDescriptor cauthentication__get_password_rsapublic_key__request__field_descriptors[1] =
+{
+  {
+    "account_name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetPasswordRSAPublicKeyRequest, account_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__get_password_rsapublic_key__request__field_indices_by_name[] = {
+  0,   /* field[0] = account_name */
+};
+static const ProtobufCIntRange cauthentication__get_password_rsapublic_key__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication__get_password_rsapublic_key__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_GetPasswordRSAPublicKey_Request",
+  "CAuthenticationGetPasswordRSAPublicKeyRequest",
+  "CAuthenticationGetPasswordRSAPublicKeyRequest",
+  "",
+  sizeof(CAuthenticationGetPasswordRSAPublicKeyRequest),
+  1,
+  cauthentication__get_password_rsapublic_key__request__field_descriptors,
+  cauthentication__get_password_rsapublic_key__request__field_indices_by_name,
+  1,  cauthentication__get_password_rsapublic_key__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__get_password_rsapublic_key__response__field_descriptors[3] =
+{
+  {
+    "publickey_mod",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetPasswordRSAPublicKeyResponse, publickey_mod),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "publickey_exp",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetPasswordRSAPublicKeyResponse, publickey_exp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "timestamp",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationGetPasswordRSAPublicKeyResponse, has_timestamp),
+    offsetof(CAuthenticationGetPasswordRSAPublicKeyResponse, timestamp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__get_password_rsapublic_key__response__field_indices_by_name[] = {
+  1,   /* field[1] = publickey_exp */
+  0,   /* field[0] = publickey_mod */
+  2,   /* field[2] = timestamp */
+};
+static const ProtobufCIntRange cauthentication__get_password_rsapublic_key__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor cauthentication__get_password_rsapublic_key__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_GetPasswordRSAPublicKey_Response",
+  "CAuthenticationGetPasswordRSAPublicKeyResponse",
+  "CAuthenticationGetPasswordRSAPublicKeyResponse",
+  "",
+  sizeof(CAuthenticationGetPasswordRSAPublicKeyResponse),
+  3,
+  cauthentication__get_password_rsapublic_key__response__field_descriptors,
+  cauthentication__get_password_rsapublic_key__response__field_indices_by_name,
+  1,  cauthentication__get_password_rsapublic_key__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EAuthTokenPlatformType cauthentication__device_details__platform_type__default_value = EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown;
+static const ProtobufCFieldDescriptor cauthentication__device_details__field_descriptors[4] =
+{
+  {
+    "device_friendly_name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationDeviceDetails, device_friendly_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_type",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationDeviceDetails, has_platform_type),
+    offsetof(CAuthenticationDeviceDetails, platform_type),
+    &eauth_token_platform_type__descriptor,
+    &cauthentication__device_details__platform_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "os_type",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CAuthenticationDeviceDetails, has_os_type),
+    offsetof(CAuthenticationDeviceDetails, os_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "gaming_device_type",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CAuthenticationDeviceDetails, has_gaming_device_type),
+    offsetof(CAuthenticationDeviceDetails, gaming_device_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__device_details__field_indices_by_name[] = {
+  0,   /* field[0] = device_friendly_name */
+  3,   /* field[3] = gaming_device_type */
+  2,   /* field[2] = os_type */
+  1,   /* field[1] = platform_type */
+};
+static const ProtobufCIntRange cauthentication__device_details__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 4 }
+};
+const ProtobufCMessageDescriptor cauthentication__device_details__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_DeviceDetails",
+  "CAuthenticationDeviceDetails",
+  "CAuthenticationDeviceDetails",
+  "",
+  sizeof(CAuthenticationDeviceDetails),
+  4,
+  cauthentication__device_details__field_descriptors,
+  cauthentication__device_details__field_indices_by_name,
+  1,  cauthentication__device_details__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+char cauthentication__begin_auth_session_via_qr__request__website_id__default_value[] = "Unknown";
+static const EAuthTokenPlatformType cauthentication__begin_auth_session_via_qr__request__platform_type__default_value = EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown;
+static const ProtobufCFieldDescriptor cauthentication__begin_auth_session_via_qr__request__field_descriptors[4] =
+{
+  {
+    "device_friendly_name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaQRRequest, device_friendly_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_type",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationBeginAuthSessionViaQRRequest, has_platform_type),
+    offsetof(CAuthenticationBeginAuthSessionViaQRRequest, platform_type),
+    &eauth_token_platform_type__descriptor,
+    &cauthentication__begin_auth_session_via_qr__request__platform_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "device_details",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaQRRequest, device_details),
+    &cauthentication__device_details__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "website_id",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaQRRequest, website_id),
+    NULL,
+    &cauthentication__begin_auth_session_via_qr__request__website_id__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__begin_auth_session_via_qr__request__field_indices_by_name[] = {
+  2,   /* field[2] = device_details */
+  0,   /* field[0] = device_friendly_name */
+  1,   /* field[1] = platform_type */
+  3,   /* field[3] = website_id */
+};
+static const ProtobufCIntRange cauthentication__begin_auth_session_via_qr__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 4 }
+};
+const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_qr__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_BeginAuthSessionViaQR_Request",
+  "CAuthenticationBeginAuthSessionViaQRRequest",
+  "CAuthenticationBeginAuthSessionViaQRRequest",
+  "",
+  sizeof(CAuthenticationBeginAuthSessionViaQRRequest),
+  4,
+  cauthentication__begin_auth_session_via_qr__request__field_descriptors,
+  cauthentication__begin_auth_session_via_qr__request__field_indices_by_name,
+  1,  cauthentication__begin_auth_session_via_qr__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EAuthSessionGuardType cauthentication__allowed_confirmation__confirmation_type__default_value = EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_Unknown;
+static const ProtobufCFieldDescriptor cauthentication__allowed_confirmation__field_descriptors[2] =
+{
+  {
+    "confirmation_type",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationAllowedConfirmation, has_confirmation_type),
+    offsetof(CAuthenticationAllowedConfirmation, confirmation_type),
+    &eauth_session_guard_type__descriptor,
+    &cauthentication__allowed_confirmation__confirmation_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "associated_message",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationAllowedConfirmation, associated_message),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__allowed_confirmation__field_indices_by_name[] = {
+  1,   /* field[1] = associated_message */
+  0,   /* field[0] = confirmation_type */
+};
+static const ProtobufCIntRange cauthentication__allowed_confirmation__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cauthentication__allowed_confirmation__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_AllowedConfirmation",
+  "CAuthenticationAllowedConfirmation",
+  "CAuthenticationAllowedConfirmation",
+  "",
+  sizeof(CAuthenticationAllowedConfirmation),
+  2,
+  cauthentication__allowed_confirmation__field_descriptors,
+  cauthentication__allowed_confirmation__field_indices_by_name,
+  1,  cauthentication__allowed_confirmation__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__begin_auth_session_via_qr__response__field_descriptors[6] =
+{
+  {
+    "client_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, has_client_id),
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, client_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "challenge_url",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, challenge_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "request_id",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, has_request_id),
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, request_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "interval",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FLOAT,
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, has_interval),
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, interval),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "allowed_confirmations",
+    5,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, n_allowed_confirmations),
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, allowed_confirmations),
+    &cauthentication__allowed_confirmation__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "version",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, has_version),
+    offsetof(CAuthenticationBeginAuthSessionViaQRResponse, version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__begin_auth_session_via_qr__response__field_indices_by_name[] = {
+  4,   /* field[4] = allowed_confirmations */
+  1,   /* field[1] = challenge_url */
+  0,   /* field[0] = client_id */
+  3,   /* field[3] = interval */
+  2,   /* field[2] = request_id */
+  5,   /* field[5] = version */
+};
+static const ProtobufCIntRange cauthentication__begin_auth_session_via_qr__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 6 }
+};
+const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_qr__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_BeginAuthSessionViaQR_Response",
+  "CAuthenticationBeginAuthSessionViaQRResponse",
+  "CAuthenticationBeginAuthSessionViaQRResponse",
+  "",
+  sizeof(CAuthenticationBeginAuthSessionViaQRResponse),
+  6,
+  cauthentication__begin_auth_session_via_qr__response__field_descriptors,
+  cauthentication__begin_auth_session_via_qr__response__field_indices_by_name,
+  1,  cauthentication__begin_auth_session_via_qr__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+char cauthentication__begin_auth_session_via_credentials__request__website_id__default_value[] = "Unknown";
+static const EAuthTokenPlatformType cauthentication__begin_auth_session_via_credentials__request__platform_type__default_value = EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown;
+static const ESessionPersistence cauthentication__begin_auth_session_via_credentials__request__persistence__default_value = ESESSION_PERSISTENCE__k_ESessionPersistence_Persistent;
+static const int32_t cauthentication__begin_auth_session_via_credentials__request__qos_level__default_value = 2;
+static const ProtobufCFieldDescriptor cauthentication__begin_auth_session_via_credentials__request__field_descriptors[12] =
+{
+  {
+    "device_friendly_name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, device_friendly_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "account_name",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, account_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "encrypted_password",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, encrypted_password),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "encryption_timestamp",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, has_encryption_timestamp),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, encryption_timestamp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "remember_login",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, has_remember_login),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, remember_login),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_type",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, has_platform_type),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, platform_type),
+    &eauth_token_platform_type__descriptor,
+    &cauthentication__begin_auth_session_via_credentials__request__platform_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "persistence",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, has_persistence),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, persistence),
+    &esession_persistence__descriptor,
+    &cauthentication__begin_auth_session_via_credentials__request__persistence__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "website_id",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, website_id),
+    NULL,
+    &cauthentication__begin_auth_session_via_credentials__request__website_id__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "device_details",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, device_details),
+    &cauthentication__device_details__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "guard_data",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, guard_data),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "language",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, has_language),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, language),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "qos_level",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, has_qos_level),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsRequest, qos_level),
+    NULL,
+    &cauthentication__begin_auth_session_via_credentials__request__qos_level__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__begin_auth_session_via_credentials__request__field_indices_by_name[] = {
+  1,   /* field[1] = account_name */
+  8,   /* field[8] = device_details */
+  0,   /* field[0] = device_friendly_name */
+  2,   /* field[2] = encrypted_password */
+  3,   /* field[3] = encryption_timestamp */
+  9,   /* field[9] = guard_data */
+  10,   /* field[10] = language */
+  6,   /* field[6] = persistence */
+  5,   /* field[5] = platform_type */
+  11,   /* field[11] = qos_level */
+  4,   /* field[4] = remember_login */
+  7,   /* field[7] = website_id */
+};
+static const ProtobufCIntRange cauthentication__begin_auth_session_via_credentials__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 12 }
+};
+const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_credentials__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_BeginAuthSessionViaCredentials_Request",
+  "CAuthenticationBeginAuthSessionViaCredentialsRequest",
+  "CAuthenticationBeginAuthSessionViaCredentialsRequest",
+  "",
+  sizeof(CAuthenticationBeginAuthSessionViaCredentialsRequest),
+  12,
+  cauthentication__begin_auth_session_via_credentials__request__field_descriptors,
+  cauthentication__begin_auth_session_via_credentials__request__field_indices_by_name,
+  1,  cauthentication__begin_auth_session_via_credentials__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__begin_auth_session_via_credentials__response__field_descriptors[8] =
+{
+  {
+    "client_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, has_client_id),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, client_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "request_id",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, has_request_id),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, request_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "interval",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FLOAT,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, has_interval),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, interval),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "allowed_confirmations",
+    4,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, n_allowed_confirmations),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, allowed_confirmations),
+    &cauthentication__allowed_confirmation__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamid",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, has_steamid),
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "weak_token",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, weak_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "agreement_session_url",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, agreement_session_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "extended_error_message",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationBeginAuthSessionViaCredentialsResponse, extended_error_message),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__begin_auth_session_via_credentials__response__field_indices_by_name[] = {
+  6,   /* field[6] = agreement_session_url */
+  3,   /* field[3] = allowed_confirmations */
+  0,   /* field[0] = client_id */
+  7,   /* field[7] = extended_error_message */
+  2,   /* field[2] = interval */
+  1,   /* field[1] = request_id */
+  4,   /* field[4] = steamid */
+  5,   /* field[5] = weak_token */
+};
+static const ProtobufCIntRange cauthentication__begin_auth_session_via_credentials__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 8 }
+};
+const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_credentials__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_BeginAuthSessionViaCredentials_Response",
+  "CAuthenticationBeginAuthSessionViaCredentialsResponse",
+  "CAuthenticationBeginAuthSessionViaCredentialsResponse",
+  "",
+  sizeof(CAuthenticationBeginAuthSessionViaCredentialsResponse),
+  8,
+  cauthentication__begin_auth_session_via_credentials__response__field_descriptors,
+  cauthentication__begin_auth_session_via_credentials__response__field_indices_by_name,
+  1,  cauthentication__begin_auth_session_via_credentials__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__poll_auth_session_status__request__field_descriptors[3] =
+{
+  {
+    "client_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationPollAuthSessionStatusRequest, has_client_id),
+    offsetof(CAuthenticationPollAuthSessionStatusRequest, client_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "request_id",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CAuthenticationPollAuthSessionStatusRequest, has_request_id),
+    offsetof(CAuthenticationPollAuthSessionStatusRequest, request_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_to_revoke",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationPollAuthSessionStatusRequest, has_token_to_revoke),
+    offsetof(CAuthenticationPollAuthSessionStatusRequest, token_to_revoke),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__poll_auth_session_status__request__field_indices_by_name[] = {
+  0,   /* field[0] = client_id */
+  1,   /* field[1] = request_id */
+  2,   /* field[2] = token_to_revoke */
+};
+static const ProtobufCIntRange cauthentication__poll_auth_session_status__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor cauthentication__poll_auth_session_status__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_PollAuthSessionStatus_Request",
+  "CAuthenticationPollAuthSessionStatusRequest",
+  "CAuthenticationPollAuthSessionStatusRequest",
+  "",
+  sizeof(CAuthenticationPollAuthSessionStatusRequest),
+  3,
+  cauthentication__poll_auth_session_status__request__field_descriptors,
+  cauthentication__poll_auth_session_status__request__field_indices_by_name,
+  1,  cauthentication__poll_auth_session_status__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__poll_auth_session_status__response__field_descriptors[8] =
+{
+  {
+    "new_client_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, has_new_client_id),
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, new_client_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "new_challenge_url",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, new_challenge_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "refresh_token",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, refresh_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "access_token",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, access_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "had_remote_interaction",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, has_had_remote_interaction),
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, had_remote_interaction),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "account_name",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, account_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "new_guard_data",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, new_guard_data),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "agreement_session_url",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationPollAuthSessionStatusResponse, agreement_session_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__poll_auth_session_status__response__field_indices_by_name[] = {
+  3,   /* field[3] = access_token */
+  5,   /* field[5] = account_name */
+  7,   /* field[7] = agreement_session_url */
+  4,   /* field[4] = had_remote_interaction */
+  1,   /* field[1] = new_challenge_url */
+  0,   /* field[0] = new_client_id */
+  6,   /* field[6] = new_guard_data */
+  2,   /* field[2] = refresh_token */
+};
+static const ProtobufCIntRange cauthentication__poll_auth_session_status__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 8 }
+};
+const ProtobufCMessageDescriptor cauthentication__poll_auth_session_status__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_PollAuthSessionStatus_Response",
+  "CAuthenticationPollAuthSessionStatusResponse",
+  "CAuthenticationPollAuthSessionStatusResponse",
+  "",
+  sizeof(CAuthenticationPollAuthSessionStatusResponse),
+  8,
+  cauthentication__poll_auth_session_status__response__field_descriptors,
+  cauthentication__poll_auth_session_status__response__field_indices_by_name,
+  1,  cauthentication__poll_auth_session_status__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__get_auth_session_info__request__field_descriptors[1] =
+{
+  {
+    "client_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationGetAuthSessionInfoRequest, has_client_id),
+    offsetof(CAuthenticationGetAuthSessionInfoRequest, client_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__get_auth_session_info__request__field_indices_by_name[] = {
+  0,   /* field[0] = client_id */
+};
+static const ProtobufCIntRange cauthentication__get_auth_session_info__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication__get_auth_session_info__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_GetAuthSessionInfo_Request",
+  "CAuthenticationGetAuthSessionInfoRequest",
+  "CAuthenticationGetAuthSessionInfoRequest",
+  "",
+  sizeof(CAuthenticationGetAuthSessionInfoRequest),
+  1,
+  cauthentication__get_auth_session_info__request__field_descriptors,
+  cauthentication__get_auth_session_info__request__field_indices_by_name,
+  1,  cauthentication__get_auth_session_info__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EAuthTokenPlatformType cauthentication__get_auth_session_info__response__platform_type__default_value = EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown;
+static const EAuthSessionSecurityHistory cauthentication__get_auth_session_info__response__login_history__default_value = EAUTH_SESSION_SECURITY_HISTORY__k_EAuthSessionSecurityHistory_Invalid;
+static const ESessionPersistence cauthentication__get_auth_session_info__response__requested_persistence__default_value = ESESSION_PERSISTENCE__k_ESessionPersistence_Invalid;
+static const ProtobufCFieldDescriptor cauthentication__get_auth_session_info__response__field_descriptors[12] =
+{
+  {
+    "ip",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, ip),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "geoloc",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, geoloc),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "city",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, city),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "state",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, state),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "country",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, country),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_type",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, has_platform_type),
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, platform_type),
+    &eauth_token_platform_type__descriptor,
+    &cauthentication__get_auth_session_info__response__platform_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "device_friendly_name",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, device_friendly_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "version",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, has_version),
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "login_history",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, has_login_history),
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, login_history),
+    &eauth_session_security_history__descriptor,
+    &cauthentication__get_auth_session_info__response__login_history__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "requestor_location_mismatch",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, has_requestor_location_mismatch),
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, requestor_location_mismatch),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "high_usage_login",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, has_high_usage_login),
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, high_usage_login),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "requested_persistence",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, has_requested_persistence),
+    offsetof(CAuthenticationGetAuthSessionInfoResponse, requested_persistence),
+    &esession_persistence__descriptor,
+    &cauthentication__get_auth_session_info__response__requested_persistence__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__get_auth_session_info__response__field_indices_by_name[] = {
+  2,   /* field[2] = city */
+  4,   /* field[4] = country */
+  6,   /* field[6] = device_friendly_name */
+  1,   /* field[1] = geoloc */
+  10,   /* field[10] = high_usage_login */
+  0,   /* field[0] = ip */
+  8,   /* field[8] = login_history */
+  5,   /* field[5] = platform_type */
+  11,   /* field[11] = requested_persistence */
+  9,   /* field[9] = requestor_location_mismatch */
+  3,   /* field[3] = state */
+  7,   /* field[7] = version */
+};
+static const ProtobufCIntRange cauthentication__get_auth_session_info__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 12 }
+};
+const ProtobufCMessageDescriptor cauthentication__get_auth_session_info__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_GetAuthSessionInfo_Response",
+  "CAuthenticationGetAuthSessionInfoResponse",
+  "CAuthenticationGetAuthSessionInfoResponse",
+  "",
+  sizeof(CAuthenticationGetAuthSessionInfoResponse),
+  12,
+  cauthentication__get_auth_session_info__response__field_descriptors,
+  cauthentication__get_auth_session_info__response__field_indices_by_name,
+  1,  cauthentication__get_auth_session_info__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const protobuf_c_boolean cauthentication__update_auth_session_with_mobile_confirmation__request__confirm__default_value = 0;
+static const ESessionPersistence cauthentication__update_auth_session_with_mobile_confirmation__request__persistence__default_value = ESESSION_PERSISTENCE__k_ESessionPersistence_Persistent;
+static const ProtobufCFieldDescriptor cauthentication__update_auth_session_with_mobile_confirmation__request__field_descriptors[6] =
+{
+  {
+    "version",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, has_version),
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_id",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, has_client_id),
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, client_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamid",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, has_steamid),
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "signature",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, has_signature),
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, signature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "confirm",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, has_confirm),
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, confirm),
+    NULL,
+    &cauthentication__update_auth_session_with_mobile_confirmation__request__confirm__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "persistence",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, has_persistence),
+    offsetof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest, persistence),
+    &esession_persistence__descriptor,
+    &cauthentication__update_auth_session_with_mobile_confirmation__request__persistence__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__update_auth_session_with_mobile_confirmation__request__field_indices_by_name[] = {
+  1,   /* field[1] = client_id */
+  4,   /* field[4] = confirm */
+  5,   /* field[5] = persistence */
+  3,   /* field[3] = signature */
+  2,   /* field[2] = steamid */
+  0,   /* field[0] = version */
+};
+static const ProtobufCIntRange cauthentication__update_auth_session_with_mobile_confirmation__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 6 }
+};
+const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_UpdateAuthSessionWithMobileConfirmation_Request",
+  "CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest",
+  "CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest",
+  "",
+  sizeof(CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest),
+  6,
+  cauthentication__update_auth_session_with_mobile_confirmation__request__field_descriptors,
+  cauthentication__update_auth_session_with_mobile_confirmation__request__field_indices_by_name,
+  1,  cauthentication__update_auth_session_with_mobile_confirmation__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+#define cauthentication__update_auth_session_with_mobile_confirmation__response__field_descriptors NULL
+#define cauthentication__update_auth_session_with_mobile_confirmation__response__field_indices_by_name NULL
+#define cauthentication__update_auth_session_with_mobile_confirmation__response__number_ranges NULL
+const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_UpdateAuthSessionWithMobileConfirmation_Response",
+  "CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse",
+  "CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse",
+  "",
+  sizeof(CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse),
+  0,
+  cauthentication__update_auth_session_with_mobile_confirmation__response__field_descriptors,
+  cauthentication__update_auth_session_with_mobile_confirmation__response__field_indices_by_name,
+  0,  cauthentication__update_auth_session_with_mobile_confirmation__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EAuthSessionGuardType cauthentication__update_auth_session_with_steam_guard_code__request__code_type__default_value = EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_Unknown;
+static const ProtobufCFieldDescriptor cauthentication__update_auth_session_with_steam_guard_code__request__field_descriptors[4] =
+{
+  {
+    "client_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest, has_client_id),
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest, client_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest, has_steamid),
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "code",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest, code),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "code_type",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest, has_code_type),
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest, code_type),
+    &eauth_session_guard_type__descriptor,
+    &cauthentication__update_auth_session_with_steam_guard_code__request__code_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__update_auth_session_with_steam_guard_code__request__field_indices_by_name[] = {
+  0,   /* field[0] = client_id */
+  2,   /* field[2] = code */
+  3,   /* field[3] = code_type */
+  1,   /* field[1] = steamid */
+};
+static const ProtobufCIntRange cauthentication__update_auth_session_with_steam_guard_code__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 4 }
+};
+const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_steam_guard_code__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_UpdateAuthSessionWithSteamGuardCode_Request",
+  "CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest",
+  "CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest",
+  "",
+  sizeof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest),
+  4,
+  cauthentication__update_auth_session_with_steam_guard_code__request__field_descriptors,
+  cauthentication__update_auth_session_with_steam_guard_code__request__field_indices_by_name,
+  1,  cauthentication__update_auth_session_with_steam_guard_code__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__update_auth_session_with_steam_guard_code__response__field_descriptors[1] =
+{
+  {
+    "agreement_session_url",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse, agreement_session_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__update_auth_session_with_steam_guard_code__response__field_indices_by_name[] = {
+  0,   /* field[0] = agreement_session_url */
+};
+static const ProtobufCIntRange cauthentication__update_auth_session_with_steam_guard_code__response__number_ranges[1 + 1] =
+{
+  { 7, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_steam_guard_code__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_UpdateAuthSessionWithSteamGuardCode_Response",
+  "CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse",
+  "CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse",
+  "",
+  sizeof(CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse),
+  1,
+  cauthentication__update_auth_session_with_steam_guard_code__response__field_descriptors,
+  cauthentication__update_auth_session_with_steam_guard_code__response__field_indices_by_name,
+  1,  cauthentication__update_auth_session_with_steam_guard_code__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__access_token__generate_for_app__request__field_descriptors[2] =
+{
+  {
+    "refresh_token",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationAccessTokenGenerateForAppRequest, refresh_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationAccessTokenGenerateForAppRequest, has_steamid),
+    offsetof(CAuthenticationAccessTokenGenerateForAppRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__access_token__generate_for_app__request__field_indices_by_name[] = {
+  0,   /* field[0] = refresh_token */
+  1,   /* field[1] = steamid */
+};
+static const ProtobufCIntRange cauthentication__access_token__generate_for_app__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cauthentication__access_token__generate_for_app__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_AccessToken_GenerateForApp_Request",
+  "CAuthenticationAccessTokenGenerateForAppRequest",
+  "CAuthenticationAccessTokenGenerateForAppRequest",
+  "",
+  sizeof(CAuthenticationAccessTokenGenerateForAppRequest),
+  2,
+  cauthentication__access_token__generate_for_app__request__field_descriptors,
+  cauthentication__access_token__generate_for_app__request__field_indices_by_name,
+  1,  cauthentication__access_token__generate_for_app__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__access_token__generate_for_app__response__field_descriptors[1] =
+{
+  {
+    "access_token",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationAccessTokenGenerateForAppResponse, access_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__access_token__generate_for_app__response__field_indices_by_name[] = {
+  0,   /* field[0] = access_token */
+};
+static const ProtobufCIntRange cauthentication__access_token__generate_for_app__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication__access_token__generate_for_app__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_AccessToken_GenerateForApp_Response",
+  "CAuthenticationAccessTokenGenerateForAppResponse",
+  "CAuthenticationAccessTokenGenerateForAppResponse",
+  "",
+  sizeof(CAuthenticationAccessTokenGenerateForAppResponse),
+  1,
+  cauthentication__access_token__generate_for_app__response__field_descriptors,
+  cauthentication__access_token__generate_for_app__response__field_indices_by_name,
+  1,  cauthentication__access_token__generate_for_app__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+#define cauthentication__refresh_token__enumerate__request__field_descriptors NULL
+#define cauthentication__refresh_token__enumerate__request__field_indices_by_name NULL
+#define cauthentication__refresh_token__enumerate__request__number_ranges NULL
+const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_RefreshToken_Enumerate_Request",
+  "CAuthenticationRefreshTokenEnumerateRequest",
+  "CAuthenticationRefreshTokenEnumerateRequest",
+  "",
+  sizeof(CAuthenticationRefreshTokenEnumerateRequest),
+  0,
+  cauthentication__refresh_token__enumerate__request__field_descriptors,
+  cauthentication__refresh_token__enumerate__request__field_indices_by_name,
+  0,  cauthentication__refresh_token__enumerate__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__refresh_token__enumerate__response__token_usage_event__field_descriptors[6] =
+{
+  {
+    "time",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent, has_time),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent, time),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ip",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent, ip),
+    &cmsg_ipaddress__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "locale",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent, locale),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "country",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent, country),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "state",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent, state),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "city",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent, city),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__refresh_token__enumerate__response__token_usage_event__field_indices_by_name[] = {
+  5,   /* field[5] = city */
+  3,   /* field[3] = country */
+  1,   /* field[1] = ip */
+  2,   /* field[2] = locale */
+  4,   /* field[4] = state */
+  0,   /* field[0] = time */
+};
+static const ProtobufCIntRange cauthentication__refresh_token__enumerate__response__token_usage_event__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 6 }
+};
+const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__response__token_usage_event__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_RefreshToken_Enumerate_Response.TokenUsageEvent",
+  "TokenUsageEvent",
+  "CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent",
+  "",
+  sizeof(CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent),
+  6,
+  cauthentication__refresh_token__enumerate__response__token_usage_event__field_descriptors,
+  cauthentication__refresh_token__enumerate__response__token_usage_event__field_indices_by_name,
+  1,  cauthentication__refresh_token__enumerate__response__token_usage_event__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EAuthTokenPlatformType cauthentication__refresh_token__enumerate__response__refresh_token_description__platform_type__default_value = EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown;
+static const ProtobufCFieldDescriptor cauthentication__refresh_token__enumerate__response__refresh_token_description__field_descriptors[11] =
+{
+  {
+    "token_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_token_id),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_description",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, token_description),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "time_updated",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_time_updated),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, time_updated),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_type",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_platform_type),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, platform_type),
+    &eauth_token_platform_type__descriptor,
+    &cauthentication__refresh_token__enumerate__response__refresh_token_description__platform_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "logged_in",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_logged_in),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, logged_in),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "os_platform",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_os_platform),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, os_platform),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "auth_type",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_auth_type),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, auth_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "gaming_device_type",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_gaming_device_type),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, gaming_device_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "first_seen",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, first_seen),
+    &cauthentication__refresh_token__enumerate__response__token_usage_event__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "last_seen",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, last_seen),
+    &cauthentication__refresh_token__enumerate__response__token_usage_event__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "os_type",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, has_os_type),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription, os_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__refresh_token__enumerate__response__refresh_token_description__field_indices_by_name[] = {
+  6,   /* field[6] = auth_type */
+  8,   /* field[8] = first_seen */
+  7,   /* field[7] = gaming_device_type */
+  9,   /* field[9] = last_seen */
+  4,   /* field[4] = logged_in */
+  5,   /* field[5] = os_platform */
+  10,   /* field[10] = os_type */
+  3,   /* field[3] = platform_type */
+  2,   /* field[2] = time_updated */
+  1,   /* field[1] = token_description */
+  0,   /* field[0] = token_id */
+};
+static const ProtobufCIntRange cauthentication__refresh_token__enumerate__response__refresh_token_description__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 11 }
+};
+const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__response__refresh_token_description__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_RefreshToken_Enumerate_Response.RefreshTokenDescription",
+  "RefreshTokenDescription",
+  "CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription",
+  "",
+  sizeof(CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription),
+  11,
+  cauthentication__refresh_token__enumerate__response__refresh_token_description__field_descriptors,
+  cauthentication__refresh_token__enumerate__response__refresh_token_description__field_indices_by_name,
+  1,  cauthentication__refresh_token__enumerate__response__refresh_token_description__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__refresh_token__enumerate__response__field_descriptors[2] =
+{
+  {
+    "refresh_tokens",
+    1,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse, n_refresh_tokens),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse, refresh_tokens),
+    &cauthentication__refresh_token__enumerate__response__refresh_token_description__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "requesting_token",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse, has_requesting_token),
+    offsetof(CAuthenticationRefreshTokenEnumerateResponse, requesting_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__refresh_token__enumerate__response__field_indices_by_name[] = {
+  0,   /* field[0] = refresh_tokens */
+  1,   /* field[1] = requesting_token */
+};
+static const ProtobufCIntRange cauthentication__refresh_token__enumerate__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_RefreshToken_Enumerate_Response",
+  "CAuthenticationRefreshTokenEnumerateResponse",
+  "CAuthenticationRefreshTokenEnumerateResponse",
+  "",
+  sizeof(CAuthenticationRefreshTokenEnumerateResponse),
+  2,
+  cauthentication__refresh_token__enumerate__response__field_descriptors,
+  cauthentication__refresh_token__enumerate__response__field_indices_by_name,
+  1,  cauthentication__refresh_token__enumerate__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+#define cauthentication__get_auth_sessions_for_account__request__field_descriptors NULL
+#define cauthentication__get_auth_sessions_for_account__request__field_indices_by_name NULL
+#define cauthentication__get_auth_sessions_for_account__request__number_ranges NULL
+const ProtobufCMessageDescriptor cauthentication__get_auth_sessions_for_account__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_GetAuthSessionsForAccount_Request",
+  "CAuthenticationGetAuthSessionsForAccountRequest",
+  "CAuthenticationGetAuthSessionsForAccountRequest",
+  "",
+  sizeof(CAuthenticationGetAuthSessionsForAccountRequest),
+  0,
+  cauthentication__get_auth_sessions_for_account__request__field_descriptors,
+  cauthentication__get_auth_sessions_for_account__request__field_indices_by_name,
+  0,  cauthentication__get_auth_sessions_for_account__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__get_auth_sessions_for_account__response__field_descriptors[1] =
+{
+  {
+    "client_ids",
+    1,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CAuthenticationGetAuthSessionsForAccountResponse, n_client_ids),
+    offsetof(CAuthenticationGetAuthSessionsForAccountResponse, client_ids),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__get_auth_sessions_for_account__response__field_indices_by_name[] = {
+  0,   /* field[0] = client_ids */
+};
+static const ProtobufCIntRange cauthentication__get_auth_sessions_for_account__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication__get_auth_sessions_for_account__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_GetAuthSessionsForAccount_Response",
+  "CAuthenticationGetAuthSessionsForAccountResponse",
+  "CAuthenticationGetAuthSessionsForAccountResponse",
+  "",
+  sizeof(CAuthenticationGetAuthSessionsForAccountResponse),
+  1,
+  cauthentication__get_auth_sessions_for_account__response__field_descriptors,
+  cauthentication__get_auth_sessions_for_account__response__field_indices_by_name,
+  1,  cauthentication__get_auth_sessions_for_account__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__migrate_mobile_session__request__field_descriptors[3] =
+{
+  {
+    "steamid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationMigrateMobileSessionRequest, has_steamid),
+    offsetof(CAuthenticationMigrateMobileSessionRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationMigrateMobileSessionRequest, token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "signature",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationMigrateMobileSessionRequest, signature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__migrate_mobile_session__request__field_indices_by_name[] = {
+  2,   /* field[2] = signature */
+  0,   /* field[0] = steamid */
+  1,   /* field[1] = token */
+};
+static const ProtobufCIntRange cauthentication__migrate_mobile_session__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor cauthentication__migrate_mobile_session__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_MigrateMobileSession_Request",
+  "CAuthenticationMigrateMobileSessionRequest",
+  "CAuthenticationMigrateMobileSessionRequest",
+  "",
+  sizeof(CAuthenticationMigrateMobileSessionRequest),
+  3,
+  cauthentication__migrate_mobile_session__request__field_descriptors,
+  cauthentication__migrate_mobile_session__request__field_indices_by_name,
+  1,  cauthentication__migrate_mobile_session__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication__migrate_mobile_session__response__field_descriptors[2] =
+{
+  {
+    "refresh_token",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationMigrateMobileSessionResponse, refresh_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "access_token",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CAuthenticationMigrateMobileSessionResponse, access_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__migrate_mobile_session__response__field_indices_by_name[] = {
+  1,   /* field[1] = access_token */
+  0,   /* field[0] = refresh_token */
+};
+static const ProtobufCIntRange cauthentication__migrate_mobile_session__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cauthentication__migrate_mobile_session__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_MigrateMobileSession_Response",
+  "CAuthenticationMigrateMobileSessionResponse",
+  "CAuthenticationMigrateMobileSessionResponse",
+  "",
+  sizeof(CAuthenticationMigrateMobileSessionResponse),
+  2,
+  cauthentication__migrate_mobile_session__response__field_descriptors,
+  cauthentication__migrate_mobile_session__response__field_indices_by_name,
+  1,  cauthentication__migrate_mobile_session__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EAuthTokenRevokeAction cauthentication__refresh_token__revoke__request__revoke_action__default_value = EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokePermanent;
+static const ProtobufCFieldDescriptor cauthentication__refresh_token__revoke__request__field_descriptors[4] =
+{
+  {
+    "token_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, has_token_id),
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, has_steamid),
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "revoke_action",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, has_revoke_action),
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, revoke_action),
+    &eauth_token_revoke_action__descriptor,
+    &cauthentication__refresh_token__revoke__request__revoke_action__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "signature",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, has_signature),
+    offsetof(CAuthenticationRefreshTokenRevokeRequest, signature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication__refresh_token__revoke__request__field_indices_by_name[] = {
+  2,   /* field[2] = revoke_action */
+  3,   /* field[3] = signature */
+  1,   /* field[1] = steamid */
+  0,   /* field[0] = token_id */
+};
+static const ProtobufCIntRange cauthentication__refresh_token__revoke__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 4 }
+};
+const ProtobufCMessageDescriptor cauthentication__refresh_token__revoke__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_RefreshToken_Revoke_Request",
+  "CAuthenticationRefreshTokenRevokeRequest",
+  "CAuthenticationRefreshTokenRevokeRequest",
+  "",
+  sizeof(CAuthenticationRefreshTokenRevokeRequest),
+  4,
+  cauthentication__refresh_token__revoke__request__field_descriptors,
+  cauthentication__refresh_token__revoke__request__field_indices_by_name,
+  1,  cauthentication__refresh_token__revoke__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+#define cauthentication__refresh_token__revoke__response__field_descriptors NULL
+#define cauthentication__refresh_token__revoke__response__field_indices_by_name NULL
+#define cauthentication__refresh_token__revoke__response__number_ranges NULL
+const ProtobufCMessageDescriptor cauthentication__refresh_token__revoke__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthentication_RefreshToken_Revoke_Response",
+  "CAuthenticationRefreshTokenRevokeResponse",
+  "CAuthenticationRefreshTokenRevokeResponse",
+  "",
+  sizeof(CAuthenticationRefreshTokenRevokeResponse),
+  0,
+  cauthentication__refresh_token__revoke__response__field_descriptors,
+  cauthentication__refresh_token__revoke__response__field_indices_by_name,
+  0,  cauthentication__refresh_token__revoke__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication_support__query_refresh_tokens_by_account__request__field_descriptors[2] =
+{
+  {
+    "steamid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountRequest, has_steamid),
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "include_revoked_tokens",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountRequest, has_include_revoked_tokens),
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountRequest, include_revoked_tokens),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication_support__query_refresh_tokens_by_account__request__field_indices_by_name[] = {
+  1,   /* field[1] = include_revoked_tokens */
+  0,   /* field[0] = steamid */
+};
+static const ProtobufCIntRange cauthentication_support__query_refresh_tokens_by_account__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cauthentication_support__query_refresh_tokens_by_account__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_QueryRefreshTokensByAccount_Request",
+  "CAuthenticationSupportQueryRefreshTokensByAccountRequest",
+  "CAuthenticationSupportQueryRefreshTokensByAccountRequest",
+  "",
+  sizeof(CAuthenticationSupportQueryRefreshTokensByAccountRequest),
+  2,
+  cauthentication_support__query_refresh_tokens_by_account__request__field_descriptors,
+  cauthentication_support__query_refresh_tokens_by_account__request__field_indices_by_name,
+  1,  cauthentication_support__query_refresh_tokens_by_account__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor csupport_refresh_token_description__token_usage_event__field_descriptors[5] =
+{
+  {
+    "time",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CSupportRefreshTokenDescription__TokenUsageEvent, has_time),
+    offsetof(CSupportRefreshTokenDescription__TokenUsageEvent, time),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ip",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenDescription__TokenUsageEvent, ip),
+    &cmsg_ipaddress__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "country",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenDescription__TokenUsageEvent, country),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "state",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenDescription__TokenUsageEvent, state),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "city",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenDescription__TokenUsageEvent, city),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned csupport_refresh_token_description__token_usage_event__field_indices_by_name[] = {
+  4,   /* field[4] = city */
+  2,   /* field[2] = country */
+  1,   /* field[1] = ip */
+  3,   /* field[3] = state */
+  0,   /* field[0] = time */
+};
+static const ProtobufCIntRange csupport_refresh_token_description__token_usage_event__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 5 }
+};
+const ProtobufCMessageDescriptor csupport_refresh_token_description__token_usage_event__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CSupportRefreshTokenDescription.TokenUsageEvent",
+  "TokenUsageEvent",
+  "CSupportRefreshTokenDescription__TokenUsageEvent",
+  "",
+  sizeof(CSupportRefreshTokenDescription__TokenUsageEvent),
+  5,
+  csupport_refresh_token_description__token_usage_event__field_descriptors,
+  csupport_refresh_token_description__token_usage_event__field_indices_by_name,
+  1,  csupport_refresh_token_description__token_usage_event__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EAuthTokenPlatformType csupport_refresh_token_description__platform_type__default_value = EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown;
+static const EAuthTokenState csupport_refresh_token_description__token_state__default_value = EAUTH_TOKEN_STATE__k_EAuthTokenState_Invalid;
+static const ProtobufCFieldDescriptor csupport_refresh_token_description__field_descriptors[12] =
+{
+  {
+    "token_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CSupportRefreshTokenDescription, has_token_id),
+    offsetof(CSupportRefreshTokenDescription, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_description",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenDescription, token_description),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "time_updated",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CSupportRefreshTokenDescription, has_time_updated),
+    offsetof(CSupportRefreshTokenDescription, time_updated),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_type",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CSupportRefreshTokenDescription, has_platform_type),
+    offsetof(CSupportRefreshTokenDescription, platform_type),
+    &eauth_token_platform_type__descriptor,
+    &csupport_refresh_token_description__platform_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_state",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CSupportRefreshTokenDescription, has_token_state),
+    offsetof(CSupportRefreshTokenDescription, token_state),
+    &eauth_token_state__descriptor,
+    &csupport_refresh_token_description__token_state__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "owner_steamid",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CSupportRefreshTokenDescription, has_owner_steamid),
+    offsetof(CSupportRefreshTokenDescription, owner_steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "os_platform",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CSupportRefreshTokenDescription, has_os_platform),
+    offsetof(CSupportRefreshTokenDescription, os_platform),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "os_type",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CSupportRefreshTokenDescription, has_os_type),
+    offsetof(CSupportRefreshTokenDescription, os_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "auth_type",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CSupportRefreshTokenDescription, has_auth_type),
+    offsetof(CSupportRefreshTokenDescription, auth_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "gaming_device_type",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CSupportRefreshTokenDescription, has_gaming_device_type),
+    offsetof(CSupportRefreshTokenDescription, gaming_device_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "first_seen",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenDescription, first_seen),
+    &csupport_refresh_token_description__token_usage_event__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "last_seen",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenDescription, last_seen),
+    &csupport_refresh_token_description__token_usage_event__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned csupport_refresh_token_description__field_indices_by_name[] = {
+  8,   /* field[8] = auth_type */
+  10,   /* field[10] = first_seen */
+  9,   /* field[9] = gaming_device_type */
+  11,   /* field[11] = last_seen */
+  6,   /* field[6] = os_platform */
+  7,   /* field[7] = os_type */
+  5,   /* field[5] = owner_steamid */
+  3,   /* field[3] = platform_type */
+  2,   /* field[2] = time_updated */
+  1,   /* field[1] = token_description */
+  0,   /* field[0] = token_id */
+  4,   /* field[4] = token_state */
+};
+static const ProtobufCIntRange csupport_refresh_token_description__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 12 }
+};
+const ProtobufCMessageDescriptor csupport_refresh_token_description__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CSupportRefreshTokenDescription",
+  "CSupportRefreshTokenDescription",
+  "CSupportRefreshTokenDescription",
+  "",
+  sizeof(CSupportRefreshTokenDescription),
+  12,
+  csupport_refresh_token_description__field_descriptors,
+  csupport_refresh_token_description__field_indices_by_name,
+  1,  csupport_refresh_token_description__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication_support__query_refresh_tokens_by_account__response__field_descriptors[2] =
+{
+  {
+    "refresh_tokens",
+    1,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountResponse, n_refresh_tokens),
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountResponse, refresh_tokens),
+    &csupport_refresh_token_description__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "last_token_reset",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountResponse, has_last_token_reset),
+    offsetof(CAuthenticationSupportQueryRefreshTokensByAccountResponse, last_token_reset),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication_support__query_refresh_tokens_by_account__response__field_indices_by_name[] = {
+  1,   /* field[1] = last_token_reset */
+  0,   /* field[0] = refresh_tokens */
+};
+static const ProtobufCIntRange cauthentication_support__query_refresh_tokens_by_account__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cauthentication_support__query_refresh_tokens_by_account__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_QueryRefreshTokensByAccount_Response",
+  "CAuthenticationSupportQueryRefreshTokensByAccountResponse",
+  "CAuthenticationSupportQueryRefreshTokensByAccountResponse",
+  "",
+  sizeof(CAuthenticationSupportQueryRefreshTokensByAccountResponse),
+  2,
+  cauthentication_support__query_refresh_tokens_by_account__response__field_descriptors,
+  cauthentication_support__query_refresh_tokens_by_account__response__field_indices_by_name,
+  1,  cauthentication_support__query_refresh_tokens_by_account__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication_support__query_refresh_token_by_id__request__field_descriptors[1] =
+{
+  {
+    "token_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationSupportQueryRefreshTokenByIDRequest, has_token_id),
+    offsetof(CAuthenticationSupportQueryRefreshTokenByIDRequest, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication_support__query_refresh_token_by_id__request__field_indices_by_name[] = {
+  0,   /* field[0] = token_id */
+};
+static const ProtobufCIntRange cauthentication_support__query_refresh_token_by_id__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication_support__query_refresh_token_by_id__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_QueryRefreshTokenByID_Request",
+  "CAuthenticationSupportQueryRefreshTokenByIDRequest",
+  "CAuthenticationSupportQueryRefreshTokenByIDRequest",
+  "",
+  sizeof(CAuthenticationSupportQueryRefreshTokenByIDRequest),
+  1,
+  cauthentication_support__query_refresh_token_by_id__request__field_descriptors,
+  cauthentication_support__query_refresh_token_by_id__request__field_indices_by_name,
+  1,  cauthentication_support__query_refresh_token_by_id__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication_support__query_refresh_token_by_id__response__field_descriptors[1] =
+{
+  {
+    "refresh_tokens",
+    1,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CAuthenticationSupportQueryRefreshTokenByIDResponse, n_refresh_tokens),
+    offsetof(CAuthenticationSupportQueryRefreshTokenByIDResponse, refresh_tokens),
+    &csupport_refresh_token_description__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication_support__query_refresh_token_by_id__response__field_indices_by_name[] = {
+  0,   /* field[0] = refresh_tokens */
+};
+static const ProtobufCIntRange cauthentication_support__query_refresh_token_by_id__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication_support__query_refresh_token_by_id__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_QueryRefreshTokenByID_Response",
+  "CAuthenticationSupportQueryRefreshTokenByIDResponse",
+  "CAuthenticationSupportQueryRefreshTokenByIDResponse",
+  "",
+  sizeof(CAuthenticationSupportQueryRefreshTokenByIDResponse),
+  1,
+  cauthentication_support__query_refresh_token_by_id__response__field_descriptors,
+  cauthentication_support__query_refresh_token_by_id__response__field_indices_by_name,
+  1,  cauthentication_support__query_refresh_token_by_id__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication_support__revoke_token__request__field_descriptors[2] =
+{
+  {
+    "token_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationSupportRevokeTokenRequest, has_token_id),
+    offsetof(CAuthenticationSupportRevokeTokenRequest, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationSupportRevokeTokenRequest, has_steamid),
+    offsetof(CAuthenticationSupportRevokeTokenRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication_support__revoke_token__request__field_indices_by_name[] = {
+  1,   /* field[1] = steamid */
+  0,   /* field[0] = token_id */
+};
+static const ProtobufCIntRange cauthentication_support__revoke_token__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cauthentication_support__revoke_token__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_RevokeToken_Request",
+  "CAuthenticationSupportRevokeTokenRequest",
+  "CAuthenticationSupportRevokeTokenRequest",
+  "",
+  sizeof(CAuthenticationSupportRevokeTokenRequest),
+  2,
+  cauthentication_support__revoke_token__request__field_descriptors,
+  cauthentication_support__revoke_token__request__field_indices_by_name,
+  1,  cauthentication_support__revoke_token__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+#define cauthentication_support__revoke_token__response__field_descriptors NULL
+#define cauthentication_support__revoke_token__response__field_indices_by_name NULL
+#define cauthentication_support__revoke_token__response__number_ranges NULL
+const ProtobufCMessageDescriptor cauthentication_support__revoke_token__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_RevokeToken_Response",
+  "CAuthenticationSupportRevokeTokenResponse",
+  "CAuthenticationSupportRevokeTokenResponse",
+  "",
+  sizeof(CAuthenticationSupportRevokeTokenResponse),
+  0,
+  cauthentication_support__revoke_token__response__field_descriptors,
+  cauthentication_support__revoke_token__response__field_indices_by_name,
+  0,  cauthentication_support__revoke_token__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication_support__get_token_history__request__field_descriptors[1] =
+{
+  {
+    "token_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CAuthenticationSupportGetTokenHistoryRequest, has_token_id),
+    offsetof(CAuthenticationSupportGetTokenHistoryRequest, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication_support__get_token_history__request__field_indices_by_name[] = {
+  0,   /* field[0] = token_id */
+};
+static const ProtobufCIntRange cauthentication_support__get_token_history__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication_support__get_token_history__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_GetTokenHistory_Request",
+  "CAuthenticationSupportGetTokenHistoryRequest",
+  "CAuthenticationSupportGetTokenHistoryRequest",
+  "",
+  sizeof(CAuthenticationSupportGetTokenHistoryRequest),
+  1,
+  cauthentication_support__get_token_history__request__field_descriptors,
+  cauthentication_support__get_token_history__request__field_indices_by_name,
+  1,  cauthentication_support__get_token_history__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor csupport_refresh_token_audit__field_descriptors[4] =
+{
+  {
+    "action",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CSupportRefreshTokenAudit, has_action),
+    offsetof(CSupportRefreshTokenAudit, action),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "time",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CSupportRefreshTokenAudit, has_time),
+    offsetof(CSupportRefreshTokenAudit, time),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ip",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CSupportRefreshTokenAudit, ip),
+    &cmsg_ipaddress__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "actor",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CSupportRefreshTokenAudit, has_actor),
+    offsetof(CSupportRefreshTokenAudit, actor),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned csupport_refresh_token_audit__field_indices_by_name[] = {
+  0,   /* field[0] = action */
+  3,   /* field[3] = actor */
+  2,   /* field[2] = ip */
+  1,   /* field[1] = time */
+};
+static const ProtobufCIntRange csupport_refresh_token_audit__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 4 }
+};
+const ProtobufCMessageDescriptor csupport_refresh_token_audit__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CSupportRefreshTokenAudit",
+  "CSupportRefreshTokenAudit",
+  "CSupportRefreshTokenAudit",
+  "",
+  sizeof(CSupportRefreshTokenAudit),
+  4,
+  csupport_refresh_token_audit__field_descriptors,
+  csupport_refresh_token_audit__field_indices_by_name,
+  1,  csupport_refresh_token_audit__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cauthentication_support__get_token_history__response__field_descriptors[1] =
+{
+  {
+    "history",
+    1,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CAuthenticationSupportGetTokenHistoryResponse, n_history),
+    offsetof(CAuthenticationSupportGetTokenHistoryResponse, history),
+    &csupport_refresh_token_audit__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cauthentication_support__get_token_history__response__field_indices_by_name[] = {
+  0,   /* field[0] = history */
+};
+static const ProtobufCIntRange cauthentication_support__get_token_history__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cauthentication_support__get_token_history__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CAuthenticationSupport_GetTokenHistory_Response",
+  "CAuthenticationSupportGetTokenHistoryResponse",
+  "CAuthenticationSupportGetTokenHistoryResponse",
+  "",
+  sizeof(CAuthenticationSupportGetTokenHistoryResponse),
+  1,
+  cauthentication_support__get_token_history__response__field_descriptors,
+  cauthentication_support__get_token_history__response__field_indices_by_name,
+  1,  cauthentication_support__get_token_history__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ccloud_gaming__create_nonce__request__field_descriptors[2] =
+{
+  {
+    "platform",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCloudGamingCreateNonceRequest, platform),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "appid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCloudGamingCreateNonceRequest, has_appid),
+    offsetof(CCloudGamingCreateNonceRequest, appid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccloud_gaming__create_nonce__request__field_indices_by_name[] = {
+  1,   /* field[1] = appid */
+  0,   /* field[0] = platform */
+};
+static const ProtobufCIntRange ccloud_gaming__create_nonce__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor ccloud_gaming__create_nonce__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCloudGaming_CreateNonce_Request",
+  "CCloudGamingCreateNonceRequest",
+  "CCloudGamingCreateNonceRequest",
+  "",
+  sizeof(CCloudGamingCreateNonceRequest),
+  2,
+  ccloud_gaming__create_nonce__request__field_descriptors,
+  ccloud_gaming__create_nonce__request__field_indices_by_name,
+  1,  ccloud_gaming__create_nonce__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ccloud_gaming__create_nonce__response__field_descriptors[2] =
+{
+  {
+    "nonce",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCloudGamingCreateNonceResponse, nonce),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "expiry",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCloudGamingCreateNonceResponse, has_expiry),
+    offsetof(CCloudGamingCreateNonceResponse, expiry),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccloud_gaming__create_nonce__response__field_indices_by_name[] = {
+  1,   /* field[1] = expiry */
+  0,   /* field[0] = nonce */
+};
+static const ProtobufCIntRange ccloud_gaming__create_nonce__response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor ccloud_gaming__create_nonce__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCloudGaming_CreateNonce_Response",
+  "CCloudGamingCreateNonceResponse",
+  "CCloudGamingCreateNonceResponse",
+  "",
+  sizeof(CCloudGamingCreateNonceResponse),
+  2,
+  ccloud_gaming__create_nonce__response__field_descriptors,
+  ccloud_gaming__create_nonce__response__field_indices_by_name,
+  1,  ccloud_gaming__create_nonce__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ccloud_gaming__get_time_remaining__request__field_descriptors[2] =
+{
+  {
+    "platform",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCloudGamingGetTimeRemainingRequest, platform),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "appid_list",
+    2,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCloudGamingGetTimeRemainingRequest, n_appid_list),
+    offsetof(CCloudGamingGetTimeRemainingRequest, appid_list),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccloud_gaming__get_time_remaining__request__field_indices_by_name[] = {
+  1,   /* field[1] = appid_list */
+  0,   /* field[0] = platform */
+};
+static const ProtobufCIntRange ccloud_gaming__get_time_remaining__request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor ccloud_gaming__get_time_remaining__request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCloudGaming_GetTimeRemaining_Request",
+  "CCloudGamingGetTimeRemainingRequest",
+  "CCloudGamingGetTimeRemainingRequest",
+  "",
+  sizeof(CCloudGamingGetTimeRemainingRequest),
+  2,
+  ccloud_gaming__get_time_remaining__request__field_descriptors,
+  ccloud_gaming__get_time_remaining__request__field_indices_by_name,
+  1,  ccloud_gaming__get_time_remaining__request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ccloud_gaming__time_remaining__field_descriptors[2] =
+{
+  {
+    "appid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCloudGamingTimeRemaining, has_appid),
+    offsetof(CCloudGamingTimeRemaining, appid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "minutes_remaining",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCloudGamingTimeRemaining, has_minutes_remaining),
+    offsetof(CCloudGamingTimeRemaining, minutes_remaining),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccloud_gaming__time_remaining__field_indices_by_name[] = {
+  0,   /* field[0] = appid */
+  1,   /* field[1] = minutes_remaining */
+};
+static const ProtobufCIntRange ccloud_gaming__time_remaining__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor ccloud_gaming__time_remaining__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCloudGaming_TimeRemaining",
+  "CCloudGamingTimeRemaining",
+  "CCloudGamingTimeRemaining",
+  "",
+  sizeof(CCloudGamingTimeRemaining),
+  2,
+  ccloud_gaming__time_remaining__field_descriptors,
+  ccloud_gaming__time_remaining__field_indices_by_name,
+  1,  ccloud_gaming__time_remaining__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ccloud_gaming__get_time_remaining__response__field_descriptors[1] =
+{
+  {
+    "entries",
+    2,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CCloudGamingGetTimeRemainingResponse, n_entries),
+    offsetof(CCloudGamingGetTimeRemainingResponse, entries),
+    &ccloud_gaming__time_remaining__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccloud_gaming__get_time_remaining__response__field_indices_by_name[] = {
+  0,   /* field[0] = entries */
+};
+static const ProtobufCIntRange ccloud_gaming__get_time_remaining__response__number_ranges[1 + 1] =
+{
+  { 2, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor ccloud_gaming__get_time_remaining__response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCloudGaming_GetTimeRemaining_Response",
+  "CCloudGamingGetTimeRemainingResponse",
+  "CCloudGamingGetTimeRemainingResponse",
+  "",
+  sizeof(CCloudGamingGetTimeRemainingResponse),
+  1,
+  ccloud_gaming__get_time_remaining__response__field_descriptors,
+  ccloud_gaming__get_time_remaining__response__field_indices_by_name,
+  1,  ccloud_gaming__get_time_remaining__response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCEnumValue eauth_token_platform_type__enum_values_by_number[4] =
+{
+  { "k_EAuthTokenPlatformType_Unknown", "EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown", 0 },
+  { "k_EAuthTokenPlatformType_SteamClient", "EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_SteamClient", 1 },
+  { "k_EAuthTokenPlatformType_WebBrowser", "EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_WebBrowser", 2 },
+  { "k_EAuthTokenPlatformType_MobileApp", "EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_MobileApp", 3 },
+};
+static const ProtobufCIntRange eauth_token_platform_type__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex eauth_token_platform_type__enum_values_by_name[4] =
+{
+  { "k_EAuthTokenPlatformType_MobileApp", 3 },
+  { "k_EAuthTokenPlatformType_SteamClient", 1 },
+  { "k_EAuthTokenPlatformType_Unknown", 0 },
+  { "k_EAuthTokenPlatformType_WebBrowser", 2 },
+};
+const ProtobufCEnumDescriptor eauth_token_platform_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EAuthTokenPlatformType",
+  "EAuthTokenPlatformType",
+  "EAuthTokenPlatformType",
+  "",
+  4,
+  eauth_token_platform_type__enum_values_by_number,
+  4,
+  eauth_token_platform_type__enum_values_by_name,
+  1,
+  eauth_token_platform_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eauth_session_guard_type__enum_values_by_number[8] =
+{
+  { "k_EAuthSessionGuardType_Unknown", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_Unknown", 0 },
+  { "k_EAuthSessionGuardType_None", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_None", 1 },
+  { "k_EAuthSessionGuardType_EmailCode", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_EmailCode", 2 },
+  { "k_EAuthSessionGuardType_DeviceCode", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_DeviceCode", 3 },
+  { "k_EAuthSessionGuardType_DeviceConfirmation", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_DeviceConfirmation", 4 },
+  { "k_EAuthSessionGuardType_EmailConfirmation", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_EmailConfirmation", 5 },
+  { "k_EAuthSessionGuardType_MachineToken", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_MachineToken", 6 },
+  { "k_EAuthSessionGuardType_LegacyMachineAuth", "EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_LegacyMachineAuth", 7 },
+};
+static const ProtobufCIntRange eauth_session_guard_type__value_ranges[] = {
+{0, 0},{0, 8}
+};
+static const ProtobufCEnumValueIndex eauth_session_guard_type__enum_values_by_name[8] =
+{
+  { "k_EAuthSessionGuardType_DeviceCode", 3 },
+  { "k_EAuthSessionGuardType_DeviceConfirmation", 4 },
+  { "k_EAuthSessionGuardType_EmailCode", 2 },
+  { "k_EAuthSessionGuardType_EmailConfirmation", 5 },
+  { "k_EAuthSessionGuardType_LegacyMachineAuth", 7 },
+  { "k_EAuthSessionGuardType_MachineToken", 6 },
+  { "k_EAuthSessionGuardType_None", 1 },
+  { "k_EAuthSessionGuardType_Unknown", 0 },
+};
+const ProtobufCEnumDescriptor eauth_session_guard_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EAuthSessionGuardType",
+  "EAuthSessionGuardType",
+  "EAuthSessionGuardType",
+  "",
+  8,
+  eauth_session_guard_type__enum_values_by_number,
+  8,
+  eauth_session_guard_type__enum_values_by_name,
+  1,
+  eauth_session_guard_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eauth_session_security_history__enum_values_by_number[3] =
+{
+  { "k_EAuthSessionSecurityHistory_Invalid", "EAUTH_SESSION_SECURITY_HISTORY__k_EAuthSessionSecurityHistory_Invalid", 0 },
+  { "k_EAuthSessionSecurityHistory_UsedPreviously", "EAUTH_SESSION_SECURITY_HISTORY__k_EAuthSessionSecurityHistory_UsedPreviously", 1 },
+  { "k_EAuthSessionSecurityHistory_NoPriorHistory", "EAUTH_SESSION_SECURITY_HISTORY__k_EAuthSessionSecurityHistory_NoPriorHistory", 2 },
+};
+static const ProtobufCIntRange eauth_session_security_history__value_ranges[] = {
+{0, 0},{0, 3}
+};
+static const ProtobufCEnumValueIndex eauth_session_security_history__enum_values_by_name[3] =
+{
+  { "k_EAuthSessionSecurityHistory_Invalid", 0 },
+  { "k_EAuthSessionSecurityHistory_NoPriorHistory", 2 },
+  { "k_EAuthSessionSecurityHistory_UsedPreviously", 1 },
+};
+const ProtobufCEnumDescriptor eauth_session_security_history__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EAuthSessionSecurityHistory",
+  "EAuthSessionSecurityHistory",
+  "EAuthSessionSecurityHistory",
+  "",
+  3,
+  eauth_session_security_history__enum_values_by_number,
+  3,
+  eauth_session_security_history__enum_values_by_name,
+  1,
+  eauth_session_security_history__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eauth_token_revoke_action__enum_values_by_number[5] =
+{
+  { "k_EAuthTokenRevokeLogout", "EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeLogout", 0 },
+  { "k_EAuthTokenRevokePermanent", "EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokePermanent", 1 },
+  { "k_EAuthTokenRevokeReplaced", "EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeReplaced", 2 },
+  { "k_EAuthTokenRevokeSupport", "EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeSupport", 3 },
+  { "k_EAuthTokenRevokeConsume", "EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeConsume", 4 },
+};
+static const ProtobufCIntRange eauth_token_revoke_action__value_ranges[] = {
+{0, 0},{0, 5}
+};
+static const ProtobufCEnumValueIndex eauth_token_revoke_action__enum_values_by_name[5] =
+{
+  { "k_EAuthTokenRevokeConsume", 4 },
+  { "k_EAuthTokenRevokeLogout", 0 },
+  { "k_EAuthTokenRevokePermanent", 1 },
+  { "k_EAuthTokenRevokeReplaced", 2 },
+  { "k_EAuthTokenRevokeSupport", 3 },
+};
+const ProtobufCEnumDescriptor eauth_token_revoke_action__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EAuthTokenRevokeAction",
+  "EAuthTokenRevokeAction",
+  "EAuthTokenRevokeAction",
+  "",
+  5,
+  eauth_token_revoke_action__enum_values_by_number,
+  5,
+  eauth_token_revoke_action__enum_values_by_name,
+  1,
+  eauth_token_revoke_action__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eauth_token_state__enum_values_by_number[8] =
+{
+  { "k_EAuthTokenState_Invalid", "EAUTH_TOKEN_STATE__k_EAuthTokenState_Invalid", 0 },
+  { "k_EAuthTokenState_New", "EAUTH_TOKEN_STATE__k_EAuthTokenState_New", 1 },
+  { "k_EAuthTokenState_Confirmed", "EAUTH_TOKEN_STATE__k_EAuthTokenState_Confirmed", 2 },
+  { "k_EAuthTokenState_Issued", "EAUTH_TOKEN_STATE__k_EAuthTokenState_Issued", 3 },
+  { "k_EAuthTokenState_Denied", "EAUTH_TOKEN_STATE__k_EAuthTokenState_Denied", 4 },
+  { "k_EAuthTokenState_LoggedOut", "EAUTH_TOKEN_STATE__k_EAuthTokenState_LoggedOut", 5 },
+  { "k_EAuthTokenState_Consumed", "EAUTH_TOKEN_STATE__k_EAuthTokenState_Consumed", 6 },
+  { "k_EAuthTokenState_Revoked", "EAUTH_TOKEN_STATE__k_EAuthTokenState_Revoked", 99 },
+};
+static const ProtobufCIntRange eauth_token_state__value_ranges[] = {
+{0, 0},{99, 7},{0, 8}
+};
+static const ProtobufCEnumValueIndex eauth_token_state__enum_values_by_name[8] =
+{
+  { "k_EAuthTokenState_Confirmed", 2 },
+  { "k_EAuthTokenState_Consumed", 6 },
+  { "k_EAuthTokenState_Denied", 4 },
+  { "k_EAuthTokenState_Invalid", 0 },
+  { "k_EAuthTokenState_Issued", 3 },
+  { "k_EAuthTokenState_LoggedOut", 5 },
+  { "k_EAuthTokenState_New", 1 },
+  { "k_EAuthTokenState_Revoked", 7 },
+};
+const ProtobufCEnumDescriptor eauth_token_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EAuthTokenState",
+  "EAuthTokenState",
+  "EAuthTokenState",
+  "",
+  8,
+  eauth_token_state__enum_values_by_number,
+  8,
+  eauth_token_state__enum_values_by_name,
+  2,
+  eauth_token_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCMethodDescriptor authentication__method_descriptors[12] =
+{
+  { "GetPasswordRSAPublicKey", &cauthentication__get_password_rsapublic_key__request__descriptor, &cauthentication__get_password_rsapublic_key__response__descriptor },
+  { "BeginAuthSessionViaQR", &cauthentication__begin_auth_session_via_qr__request__descriptor, &cauthentication__begin_auth_session_via_qr__response__descriptor },
+  { "BeginAuthSessionViaCredentials", &cauthentication__begin_auth_session_via_credentials__request__descriptor, &cauthentication__begin_auth_session_via_credentials__response__descriptor },
+  { "PollAuthSessionStatus", &cauthentication__poll_auth_session_status__request__descriptor, &cauthentication__poll_auth_session_status__response__descriptor },
+  { "GetAuthSessionInfo", &cauthentication__get_auth_session_info__request__descriptor, &cauthentication__get_auth_session_info__response__descriptor },
+  { "UpdateAuthSessionWithMobileConfirmation", &cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor, &cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor },
+  { "UpdateAuthSessionWithSteamGuardCode", &cauthentication__update_auth_session_with_steam_guard_code__request__descriptor, &cauthentication__update_auth_session_with_steam_guard_code__response__descriptor },
+  { "GenerateAccessTokenForApp", &cauthentication__access_token__generate_for_app__request__descriptor, &cauthentication__access_token__generate_for_app__response__descriptor },
+  { "EnumerateTokens", &cauthentication__refresh_token__enumerate__request__descriptor, &cauthentication__refresh_token__enumerate__response__descriptor },
+  { "GetAuthSessionsForAccount", &cauthentication__get_auth_sessions_for_account__request__descriptor, &cauthentication__get_auth_sessions_for_account__response__descriptor },
+  { "MigrateMobileSession", &cauthentication__migrate_mobile_session__request__descriptor, &cauthentication__migrate_mobile_session__response__descriptor },
+  { "RevokeRefreshToken", &cauthentication__refresh_token__revoke__request__descriptor, &cauthentication__refresh_token__revoke__response__descriptor },
+};
+const unsigned authentication__method_indices_by_name[] = {
+  2,        /* BeginAuthSessionViaCredentials */
+  1,        /* BeginAuthSessionViaQR */
+  8,        /* EnumerateTokens */
+  7,        /* GenerateAccessTokenForApp */
+  4,        /* GetAuthSessionInfo */
+  9,        /* GetAuthSessionsForAccount */
+  0,        /* GetPasswordRSAPublicKey */
+  10,        /* MigrateMobileSession */
+  3,        /* PollAuthSessionStatus */
+  11,        /* RevokeRefreshToken */
+  5,        /* UpdateAuthSessionWithMobileConfirmation */
+  6         /* UpdateAuthSessionWithSteamGuardCode */
+};
+const ProtobufCServiceDescriptor authentication__descriptor =
+{
+  PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC,
+  "Authentication",
+  "Authentication",
+  "Authentication",
+  "",
+  12,
+  authentication__method_descriptors,
+  authentication__method_indices_by_name
+};
+void authentication__get_password_rsapublic_key(ProtobufCService *service,
+                                                const CAuthenticationGetPasswordRSAPublicKeyRequest *input,
+                                                CAuthenticationGetPasswordRSAPublicKeyResponse_Closure closure,
+                                                void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 0, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__begin_auth_session_via_qr(ProtobufCService *service,
+                                               const CAuthenticationBeginAuthSessionViaQRRequest *input,
+                                               CAuthenticationBeginAuthSessionViaQRResponse_Closure closure,
+                                               void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 1, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__begin_auth_session_via_credentials(ProtobufCService *service,
+                                                        const CAuthenticationBeginAuthSessionViaCredentialsRequest *input,
+                                                        CAuthenticationBeginAuthSessionViaCredentialsResponse_Closure closure,
+                                                        void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 2, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__poll_auth_session_status(ProtobufCService *service,
+                                              const CAuthenticationPollAuthSessionStatusRequest *input,
+                                              CAuthenticationPollAuthSessionStatusResponse_Closure closure,
+                                              void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 3, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__get_auth_session_info(ProtobufCService *service,
+                                           const CAuthenticationGetAuthSessionInfoRequest *input,
+                                           CAuthenticationGetAuthSessionInfoResponse_Closure closure,
+                                           void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 4, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__update_auth_session_with_mobile_confirmation(ProtobufCService *service,
+                                                                  const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *input,
+                                                                  CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse_Closure closure,
+                                                                  void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 5, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__update_auth_session_with_steam_guard_code(ProtobufCService *service,
+                                                               const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *input,
+                                                               CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse_Closure closure,
+                                                               void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 6, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__generate_access_token_for_app(ProtobufCService *service,
+                                                   const CAuthenticationAccessTokenGenerateForAppRequest *input,
+                                                   CAuthenticationAccessTokenGenerateForAppResponse_Closure closure,
+                                                   void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 7, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__enumerate_tokens(ProtobufCService *service,
+                                      const CAuthenticationRefreshTokenEnumerateRequest *input,
+                                      CAuthenticationRefreshTokenEnumerateResponse_Closure closure,
+                                      void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 8, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__get_auth_sessions_for_account(ProtobufCService *service,
+                                                   const CAuthenticationGetAuthSessionsForAccountRequest *input,
+                                                   CAuthenticationGetAuthSessionsForAccountResponse_Closure closure,
+                                                   void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 9, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__migrate_mobile_session(ProtobufCService *service,
+                                            const CAuthenticationMigrateMobileSessionRequest *input,
+                                            CAuthenticationMigrateMobileSessionResponse_Closure closure,
+                                            void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 10, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__revoke_refresh_token(ProtobufCService *service,
+                                          const CAuthenticationRefreshTokenRevokeRequest *input,
+                                          CAuthenticationRefreshTokenRevokeResponse_Closure closure,
+                                          void *closure_data)
+{
+  assert(service->descriptor == &authentication__descriptor);
+  service->invoke(service, 11, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication__init (Authentication_Service *service,
+                           Authentication_ServiceDestroy destroy)
+{
+  protobuf_c_service_generated_init (&service->base,
+                                     &authentication__descriptor,
+                                     (ProtobufCServiceDestroy) destroy);
+}
+static const ProtobufCMethodDescriptor authentication_support__method_descriptors[4] =
+{
+  { "QueryRefreshTokensByAccount", &cauthentication_support__query_refresh_tokens_by_account__request__descriptor, &cauthentication_support__query_refresh_tokens_by_account__response__descriptor },
+  { "QueryRefreshTokenByID", &cauthentication_support__query_refresh_token_by_id__request__descriptor, &cauthentication_support__query_refresh_token_by_id__response__descriptor },
+  { "RevokeToken", &cauthentication_support__revoke_token__request__descriptor, &cauthentication_support__revoke_token__response__descriptor },
+  { "GetTokenHistory", &cauthentication_support__get_token_history__request__descriptor, &cauthentication_support__get_token_history__response__descriptor },
+};
+const unsigned authentication_support__method_indices_by_name[] = {
+  3,        /* GetTokenHistory */
+  1,        /* QueryRefreshTokenByID */
+  0,        /* QueryRefreshTokensByAccount */
+  2         /* RevokeToken */
+};
+const ProtobufCServiceDescriptor authentication_support__descriptor =
+{
+  PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC,
+  "AuthenticationSupport",
+  "AuthenticationSupport",
+  "AuthenticationSupport",
+  "",
+  4,
+  authentication_support__method_descriptors,
+  authentication_support__method_indices_by_name
+};
+void authentication_support__query_refresh_tokens_by_account(ProtobufCService *service,
+                                                             const CAuthenticationSupportQueryRefreshTokensByAccountRequest *input,
+                                                             CAuthenticationSupportQueryRefreshTokensByAccountResponse_Closure closure,
+                                                             void *closure_data)
+{
+  assert(service->descriptor == &authentication_support__descriptor);
+  service->invoke(service, 0, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication_support__query_refresh_token_by_id(ProtobufCService *service,
+                                                       const CAuthenticationSupportQueryRefreshTokenByIDRequest *input,
+                                                       CAuthenticationSupportQueryRefreshTokenByIDResponse_Closure closure,
+                                                       void *closure_data)
+{
+  assert(service->descriptor == &authentication_support__descriptor);
+  service->invoke(service, 1, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication_support__revoke_token(ProtobufCService *service,
+                                          const CAuthenticationSupportRevokeTokenRequest *input,
+                                          CAuthenticationSupportRevokeTokenResponse_Closure closure,
+                                          void *closure_data)
+{
+  assert(service->descriptor == &authentication_support__descriptor);
+  service->invoke(service, 2, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication_support__get_token_history(ProtobufCService *service,
+                                               const CAuthenticationSupportGetTokenHistoryRequest *input,
+                                               CAuthenticationSupportGetTokenHistoryResponse_Closure closure,
+                                               void *closure_data)
+{
+  assert(service->descriptor == &authentication_support__descriptor);
+  service->invoke(service, 3, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void authentication_support__init (AuthenticationSupport_Service *service,
+                                   AuthenticationSupport_ServiceDestroy destroy)
+{
+  protobuf_c_service_generated_init (&service->base,
+                                     &authentication_support__descriptor,
+                                     (ProtobufCServiceDestroy) destroy);
+}
+static const ProtobufCMethodDescriptor cloud_gaming__method_descriptors[2] =
+{
+  { "CreateNonce", &ccloud_gaming__create_nonce__request__descriptor, &ccloud_gaming__create_nonce__response__descriptor },
+  { "GetTimeRemaining", &ccloud_gaming__get_time_remaining__request__descriptor, &ccloud_gaming__get_time_remaining__response__descriptor },
+};
+const unsigned cloud_gaming__method_indices_by_name[] = {
+  0,        /* CreateNonce */
+  1         /* GetTimeRemaining */
+};
+const ProtobufCServiceDescriptor cloud_gaming__descriptor =
+{
+  PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC,
+  "CloudGaming",
+  "CloudGaming",
+  "CloudGaming",
+  "",
+  2,
+  cloud_gaming__method_descriptors,
+  cloud_gaming__method_indices_by_name
+};
+void cloud_gaming__create_nonce(ProtobufCService *service,
+                                const CCloudGamingCreateNonceRequest *input,
+                                CCloudGamingCreateNonceResponse_Closure closure,
+                                void *closure_data)
+{
+  assert(service->descriptor == &cloud_gaming__descriptor);
+  service->invoke(service, 0, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void cloud_gaming__get_time_remaining(ProtobufCService *service,
+                                      const CCloudGamingGetTimeRemainingRequest *input,
+                                      CCloudGamingGetTimeRemainingResponse_Closure closure,
+                                      void *closure_data)
+{
+  assert(service->descriptor == &cloud_gaming__descriptor);
+  service->invoke(service, 1, (const ProtobufCMessage *) input, (ProtobufCClosure) closure, closure_data);
+}
+void cloud_gaming__init (CloudGaming_Service *service,
+                         CloudGaming_ServiceDestroy destroy)
+{
+  protobuf_c_service_generated_init (&service->base,
+                                     &cloud_gaming__descriptor,
+                                     (ProtobufCServiceDestroy) destroy);
+}
diff --git a/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.pb-c.h b/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.pb-c.h
new file mode 100644
index 0000000000..a914c93fd5
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.pb-c.h
@@ -0,0 +1,1754 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_auth.steamclient.proto */
+
+#ifndef PROTOBUF_C_steammessages_5fauth_2esteamclient_2eproto__INCLUDED
+#define PROTOBUF_C_steammessages_5fauth_2esteamclient_2eproto__INCLUDED
+
+#include "protobuf-c.h"
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1000000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "steammessages_base.pb-c.h"
+#include "steammessages_unified_base.steamclient.pb-c.h"
+#include "enums.pb-c.h"
+
+struct CAuthenticationGetPasswordRSAPublicKeyRequest;
+struct CAuthenticationGetPasswordRSAPublicKeyResponse;
+struct CAuthenticationDeviceDetails;
+struct CAuthenticationBeginAuthSessionViaQRRequest;
+struct CAuthenticationAllowedConfirmation;
+struct CAuthenticationBeginAuthSessionViaQRResponse;
+struct CAuthenticationBeginAuthSessionViaCredentialsRequest;
+struct CAuthenticationBeginAuthSessionViaCredentialsResponse;
+struct CAuthenticationPollAuthSessionStatusRequest;
+struct CAuthenticationPollAuthSessionStatusResponse;
+struct CAuthenticationGetAuthSessionInfoRequest;
+struct CAuthenticationGetAuthSessionInfoResponse;
+struct CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest;
+struct CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse;
+struct CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest;
+struct CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse;
+struct CAuthenticationAccessTokenGenerateForAppRequest;
+struct CAuthenticationAccessTokenGenerateForAppResponse;
+struct CAuthenticationRefreshTokenEnumerateRequest;
+struct CAuthenticationRefreshTokenEnumerateResponse;
+struct CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent;
+struct CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription;
+struct CAuthenticationGetAuthSessionsForAccountRequest;
+struct CAuthenticationGetAuthSessionsForAccountResponse;
+struct CAuthenticationMigrateMobileSessionRequest;
+struct CAuthenticationMigrateMobileSessionResponse;
+struct CAuthenticationRefreshTokenRevokeRequest;
+struct CAuthenticationRefreshTokenRevokeResponse;
+struct CAuthenticationSupportQueryRefreshTokensByAccountRequest;
+struct CSupportRefreshTokenDescription;
+struct CSupportRefreshTokenDescription__TokenUsageEvent;
+struct CAuthenticationSupportQueryRefreshTokensByAccountResponse;
+struct CAuthenticationSupportQueryRefreshTokenByIDRequest;
+struct CAuthenticationSupportQueryRefreshTokenByIDResponse;
+struct CAuthenticationSupportRevokeTokenRequest;
+struct CAuthenticationSupportRevokeTokenResponse;
+struct CAuthenticationSupportGetTokenHistoryRequest;
+struct CSupportRefreshTokenAudit;
+struct CAuthenticationSupportGetTokenHistoryResponse;
+struct CCloudGamingCreateNonceRequest;
+struct CCloudGamingCreateNonceResponse;
+struct CCloudGamingGetTimeRemainingRequest;
+struct CCloudGamingTimeRemaining;
+struct CCloudGamingGetTimeRemainingResponse;
+
+
+/* --- enums --- */
+
+typedef enum _EAuthTokenPlatformType {
+  EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_Unknown = 0,
+  EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_SteamClient = 1,
+  EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_WebBrowser = 2,
+  EAUTH_TOKEN_PLATFORM_TYPE__k_EAuthTokenPlatformType_MobileApp = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EAUTH_TOKEN_PLATFORM_TYPE)
+} EAuthTokenPlatformType;
+typedef enum _EAuthSessionGuardType {
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_Unknown = 0,
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_None = 1,
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_EmailCode = 2,
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_DeviceCode = 3,
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_DeviceConfirmation = 4,
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_EmailConfirmation = 5,
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_MachineToken = 6,
+  EAUTH_SESSION_GUARD_TYPE__k_EAuthSessionGuardType_LegacyMachineAuth = 7
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EAUTH_SESSION_GUARD_TYPE)
+} EAuthSessionGuardType;
+typedef enum _EAuthSessionSecurityHistory {
+  EAUTH_SESSION_SECURITY_HISTORY__k_EAuthSessionSecurityHistory_Invalid = 0,
+  EAUTH_SESSION_SECURITY_HISTORY__k_EAuthSessionSecurityHistory_UsedPreviously = 1,
+  EAUTH_SESSION_SECURITY_HISTORY__k_EAuthSessionSecurityHistory_NoPriorHistory = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EAUTH_SESSION_SECURITY_HISTORY)
+} EAuthSessionSecurityHistory;
+typedef enum _EAuthTokenRevokeAction {
+  EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeLogout = 0,
+  EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokePermanent = 1,
+  EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeReplaced = 2,
+  EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeSupport = 3,
+  EAUTH_TOKEN_REVOKE_ACTION__k_EAuthTokenRevokeConsume = 4
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EAUTH_TOKEN_REVOKE_ACTION)
+} EAuthTokenRevokeAction;
+typedef enum _EAuthTokenState {
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_Invalid = 0,
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_New = 1,
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_Confirmed = 2,
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_Issued = 3,
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_Denied = 4,
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_LoggedOut = 5,
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_Consumed = 6,
+  EAUTH_TOKEN_STATE__k_EAuthTokenState_Revoked = 99
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EAUTH_TOKEN_STATE)
+} EAuthTokenState;
+
+/* --- descriptors --- */
+
+extern const ProtobufCEnumDescriptor    eauth_token_platform_type__descriptor;
+extern const ProtobufCEnumDescriptor    eauth_session_guard_type__descriptor;
+extern const ProtobufCEnumDescriptor    eauth_session_security_history__descriptor;
+extern const ProtobufCEnumDescriptor    eauth_token_revoke_action__descriptor;
+extern const ProtobufCEnumDescriptor    eauth_token_state__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__get_password_rsapublic_key__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__get_password_rsapublic_key__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__device_details__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_qr__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__allowed_confirmation__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_qr__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_credentials__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__begin_auth_session_via_credentials__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__poll_auth_session_status__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__poll_auth_session_status__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__get_auth_session_info__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__get_auth_session_info__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_steam_guard_code__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__update_auth_session_with_steam_guard_code__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__access_token__generate_for_app__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__access_token__generate_for_app__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__response__token_usage_event__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__refresh_token__enumerate__response__refresh_token_description__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__get_auth_sessions_for_account__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__get_auth_sessions_for_account__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__migrate_mobile_session__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__migrate_mobile_session__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__refresh_token__revoke__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication__refresh_token__revoke__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__query_refresh_tokens_by_account__request__descriptor;
+extern const ProtobufCMessageDescriptor csupport_refresh_token_description__descriptor;
+extern const ProtobufCMessageDescriptor csupport_refresh_token_description__token_usage_event__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__query_refresh_tokens_by_account__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__query_refresh_token_by_id__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__query_refresh_token_by_id__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__revoke_token__request__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__revoke_token__response__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__get_token_history__request__descriptor;
+extern const ProtobufCMessageDescriptor csupport_refresh_token_audit__descriptor;
+extern const ProtobufCMessageDescriptor cauthentication_support__get_token_history__response__descriptor;
+extern const ProtobufCMessageDescriptor ccloud_gaming__create_nonce__request__descriptor;
+extern const ProtobufCMessageDescriptor ccloud_gaming__create_nonce__response__descriptor;
+extern const ProtobufCMessageDescriptor ccloud_gaming__get_time_remaining__request__descriptor;
+extern const ProtobufCMessageDescriptor ccloud_gaming__time_remaining__descriptor;
+extern const ProtobufCMessageDescriptor ccloud_gaming__get_time_remaining__response__descriptor;
+extern const ProtobufCServiceDescriptor authentication__descriptor;
+extern const ProtobufCServiceDescriptor authentication_support__descriptor;
+extern const ProtobufCServiceDescriptor cloud_gaming__descriptor;
+
+/* --- messages --- */
+
+struct CAuthenticationGetPasswordRSAPublicKeyRequest : public ProtobufCppMessage
+{
+  CAuthenticationGetPasswordRSAPublicKeyRequest() :
+     ProtobufCppMessage(cauthentication__get_password_rsapublic_key__request__descriptor)
+  {}
+
+  char *account_name;
+};
+
+struct CAuthenticationGetPasswordRSAPublicKeyResponse : public ProtobufCppMessage
+{
+  CAuthenticationGetPasswordRSAPublicKeyResponse() :
+     ProtobufCppMessage(cauthentication__get_password_rsapublic_key__response__descriptor)
+  {}
+
+  char *publickey_mod;
+  char *publickey_exp;
+  protobuf_c_boolean has_timestamp;
+  uint64_t timestamp;
+};
+
+struct CAuthenticationDeviceDetails : public ProtobufCppMessage
+{
+  CAuthenticationDeviceDetails() :
+     ProtobufCppMessage(cauthentication__device_details__descriptor)
+  {}
+
+  char *device_friendly_name;
+  protobuf_c_boolean has_platform_type;
+  EAuthTokenPlatformType platform_type;
+  protobuf_c_boolean has_os_type;
+  int32_t os_type;
+  protobuf_c_boolean has_gaming_device_type;
+  uint32_t gaming_device_type;
+};
+
+struct CAuthenticationBeginAuthSessionViaQRRequest : public ProtobufCppMessage
+{
+  CAuthenticationBeginAuthSessionViaQRRequest() :
+     ProtobufCppMessage(cauthentication__begin_auth_session_via_qr__request__descriptor)
+  {}
+
+  char *device_friendly_name;
+  protobuf_c_boolean has_platform_type;
+  EAuthTokenPlatformType platform_type;
+  CAuthenticationDeviceDetails *device_details;
+  char *website_id;
+};
+
+struct CAuthenticationAllowedConfirmation : public ProtobufCppMessage
+{
+  CAuthenticationAllowedConfirmation() :
+     ProtobufCppMessage(cauthentication__allowed_confirmation__descriptor)
+  {}
+
+  protobuf_c_boolean has_confirmation_type;
+  EAuthSessionGuardType confirmation_type;
+  char *associated_message;
+};
+
+struct CAuthenticationBeginAuthSessionViaQRResponse : public ProtobufCppMessage
+{
+  CAuthenticationBeginAuthSessionViaQRResponse() :
+     ProtobufCppMessage(cauthentication__begin_auth_session_via_qr__response__descriptor)
+  {}
+
+  protobuf_c_boolean has_client_id;
+  uint64_t client_id;
+  char *challenge_url;
+  protobuf_c_boolean has_request_id;
+  ProtobufCBinaryData request_id;
+  protobuf_c_boolean has_interval;
+  float interval;
+  size_t n_allowed_confirmations;
+  CAuthenticationAllowedConfirmation **allowed_confirmations;
+  protobuf_c_boolean has_version;
+  int32_t version;
+};
+
+struct CAuthenticationBeginAuthSessionViaCredentialsRequest : public ProtobufCppMessage
+{
+  CAuthenticationBeginAuthSessionViaCredentialsRequest() :
+     ProtobufCppMessage(cauthentication__begin_auth_session_via_credentials__request__descriptor)
+  {}
+
+  char *device_friendly_name;
+  char *account_name;
+  char *encrypted_password;
+  protobuf_c_boolean has_encryption_timestamp;
+  uint64_t encryption_timestamp;
+  protobuf_c_boolean has_remember_login;
+  protobuf_c_boolean remember_login;
+  protobuf_c_boolean has_platform_type;
+  EAuthTokenPlatformType platform_type;
+  protobuf_c_boolean has_persistence;
+  ESessionPersistence persistence;
+  char *website_id;
+  CAuthenticationDeviceDetails *device_details;
+  char *guard_data;
+  protobuf_c_boolean has_language;
+  uint32_t language;
+  protobuf_c_boolean has_qos_level;
+  int32_t qos_level;
+};
+
+struct CAuthenticationBeginAuthSessionViaCredentialsResponse : public ProtobufCppMessage
+{
+  CAuthenticationBeginAuthSessionViaCredentialsResponse() :
+     ProtobufCppMessage(cauthentication__begin_auth_session_via_credentials__response__descriptor)
+  {}
+
+  protobuf_c_boolean has_client_id;
+  uint64_t client_id;
+  protobuf_c_boolean has_request_id;
+  ProtobufCBinaryData request_id;
+  protobuf_c_boolean has_interval;
+  float interval;
+  size_t n_allowed_confirmations;
+  CAuthenticationAllowedConfirmation **allowed_confirmations;
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  char *weak_token;
+  char *agreement_session_url;
+  char *extended_error_message;
+};
+
+struct CAuthenticationPollAuthSessionStatusRequest : public ProtobufCppMessage
+{
+  CAuthenticationPollAuthSessionStatusRequest() :
+     ProtobufCppMessage(cauthentication__poll_auth_session_status__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_client_id;
+  uint64_t client_id;
+  protobuf_c_boolean has_request_id;
+  ProtobufCBinaryData request_id;
+  protobuf_c_boolean has_token_to_revoke;
+  uint64_t token_to_revoke;
+};
+
+struct CAuthenticationPollAuthSessionStatusResponse : public ProtobufCppMessage
+{
+  CAuthenticationPollAuthSessionStatusResponse() :
+     ProtobufCppMessage(cauthentication__poll_auth_session_status__response__descriptor)
+  {}
+
+  protobuf_c_boolean has_new_client_id;
+  uint64_t new_client_id;
+  char *new_challenge_url;
+  char *refresh_token;
+  char *access_token;
+  protobuf_c_boolean has_had_remote_interaction;
+  protobuf_c_boolean had_remote_interaction;
+  char *account_name;
+  char *new_guard_data;
+  char *agreement_session_url;
+};
+
+struct CAuthenticationGetAuthSessionInfoRequest : public ProtobufCppMessage
+{
+  CAuthenticationGetAuthSessionInfoRequest() :
+     ProtobufCppMessage(cauthentication__get_auth_session_info__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_client_id;
+  uint64_t client_id;
+};
+
+struct CAuthenticationGetAuthSessionInfoResponse : public ProtobufCppMessage
+{
+  CAuthenticationGetAuthSessionInfoResponse() :
+     ProtobufCppMessage(cauthentication__get_auth_session_info__response__descriptor)
+  {}
+
+  char *ip;
+  char *geoloc;
+  char *city;
+  char *state;
+  char *country;
+  protobuf_c_boolean has_platform_type;
+  EAuthTokenPlatformType platform_type;
+  char *device_friendly_name;
+  protobuf_c_boolean has_version;
+  int32_t version;
+  protobuf_c_boolean has_login_history;
+  EAuthSessionSecurityHistory login_history;
+  protobuf_c_boolean has_requestor_location_mismatch;
+  protobuf_c_boolean requestor_location_mismatch;
+  protobuf_c_boolean has_high_usage_login;
+  protobuf_c_boolean high_usage_login;
+  protobuf_c_boolean has_requested_persistence;
+  ESessionPersistence requested_persistence;
+};
+
+struct CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest : public ProtobufCppMessage
+{
+  CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest() :
+     ProtobufCppMessage(cauthentication__update_auth_session_with_mobile_confirmation__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_version;
+  int32_t version;
+  protobuf_c_boolean has_client_id;
+  uint64_t client_id;
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  protobuf_c_boolean has_signature;
+  ProtobufCBinaryData signature;
+  protobuf_c_boolean has_confirm;
+  protobuf_c_boolean confirm;
+  protobuf_c_boolean has_persistence;
+  ESessionPersistence persistence;
+};
+
+struct CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse : public ProtobufCppMessage
+{
+  CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse() :
+     ProtobufCppMessage(cauthentication__update_auth_session_with_mobile_confirmation__response__descriptor)
+  {}
+
+};
+
+struct CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest : public ProtobufCppMessage
+{
+  CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest() :
+     ProtobufCppMessage(cauthentication__update_auth_session_with_steam_guard_code__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_client_id;
+  uint64_t client_id;
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  char *code;
+  protobuf_c_boolean has_code_type;
+  EAuthSessionGuardType code_type;
+};
+
+struct CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse : public ProtobufCppMessage
+{
+  CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse() :
+     ProtobufCppMessage(cauthentication__update_auth_session_with_steam_guard_code__response__descriptor)
+  {}
+
+  char *agreement_session_url;
+};
+
+struct CAuthenticationAccessTokenGenerateForAppRequest : public ProtobufCppMessage
+{
+  CAuthenticationAccessTokenGenerateForAppRequest() :
+     ProtobufCppMessage(cauthentication__access_token__generate_for_app__request__descriptor)
+  {}
+
+  char *refresh_token;
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+};
+
+struct CAuthenticationAccessTokenGenerateForAppResponse : public ProtobufCppMessage
+{
+  CAuthenticationAccessTokenGenerateForAppResponse() :
+     ProtobufCppMessage(cauthentication__access_token__generate_for_app__response__descriptor)
+  {}
+
+  char *access_token;
+};
+
+struct CAuthenticationRefreshTokenEnumerateRequest : public ProtobufCppMessage
+{
+  CAuthenticationRefreshTokenEnumerateRequest() :
+     ProtobufCppMessage(cauthentication__refresh_token__enumerate__request__descriptor)
+  {}
+
+};
+
+struct CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent : public ProtobufCppMessage
+{
+  CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent() :
+     ProtobufCppMessage(cauthentication__refresh_token__enumerate__response__token_usage_event__descriptor)
+  {}
+
+  protobuf_c_boolean has_time;
+  uint32_t time;
+  CMsgIPAddress *ip;
+  char *locale;
+  char *country;
+  char *state;
+  char *city;
+};
+
+struct CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription : public ProtobufCppMessage
+{
+  CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription() :
+     ProtobufCppMessage(cauthentication__refresh_token__enumerate__response__refresh_token_description__descriptor)
+  {}
+
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+  char *token_description;
+  protobuf_c_boolean has_time_updated;
+  uint32_t time_updated;
+  protobuf_c_boolean has_platform_type;
+  EAuthTokenPlatformType platform_type;
+  protobuf_c_boolean has_logged_in;
+  protobuf_c_boolean logged_in;
+  protobuf_c_boolean has_os_platform;
+  uint32_t os_platform;
+  protobuf_c_boolean has_auth_type;
+  uint32_t auth_type;
+  protobuf_c_boolean has_gaming_device_type;
+  uint32_t gaming_device_type;
+  CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent *first_seen;
+  CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent *last_seen;
+  protobuf_c_boolean has_os_type;
+  int32_t os_type;
+};
+
+struct CAuthenticationRefreshTokenEnumerateResponse : public ProtobufCppMessage
+{
+  CAuthenticationRefreshTokenEnumerateResponse() :
+     ProtobufCppMessage(cauthentication__refresh_token__enumerate__response__descriptor)
+  {}
+
+  size_t n_refresh_tokens;
+  CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription **refresh_tokens;
+  protobuf_c_boolean has_requesting_token;
+  uint64_t requesting_token;
+};
+
+struct CAuthenticationGetAuthSessionsForAccountRequest : public ProtobufCppMessage
+{
+  CAuthenticationGetAuthSessionsForAccountRequest() :
+     ProtobufCppMessage(cauthentication__get_auth_sessions_for_account__request__descriptor)
+  {}
+
+};
+
+struct CAuthenticationGetAuthSessionsForAccountResponse : public ProtobufCppMessage
+{
+  CAuthenticationGetAuthSessionsForAccountResponse() :
+     ProtobufCppMessage(cauthentication__get_auth_sessions_for_account__response__descriptor)
+  {}
+
+  size_t n_client_ids;
+  uint64_t *client_ids;
+};
+
+struct CAuthenticationMigrateMobileSessionRequest : public ProtobufCppMessage
+{
+  CAuthenticationMigrateMobileSessionRequest() :
+     ProtobufCppMessage(cauthentication__migrate_mobile_session__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  char *token;
+  char *signature;
+};
+
+struct CAuthenticationMigrateMobileSessionResponse : public ProtobufCppMessage
+{
+  CAuthenticationMigrateMobileSessionResponse() :
+     ProtobufCppMessage(cauthentication__migrate_mobile_session__response__descriptor)
+  {}
+
+  char *refresh_token;
+  char *access_token;
+};
+
+struct CAuthenticationRefreshTokenRevokeRequest : public ProtobufCppMessage
+{
+  CAuthenticationRefreshTokenRevokeRequest() :
+     ProtobufCppMessage(cauthentication__refresh_token__revoke__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  protobuf_c_boolean has_revoke_action;
+  EAuthTokenRevokeAction revoke_action;
+  protobuf_c_boolean has_signature;
+  ProtobufCBinaryData signature;
+};
+
+struct CAuthenticationRefreshTokenRevokeResponse : public ProtobufCppMessage
+{
+  CAuthenticationRefreshTokenRevokeResponse() :
+     ProtobufCppMessage(cauthentication__refresh_token__revoke__response__descriptor)
+  {}
+
+};
+
+struct CAuthenticationSupportQueryRefreshTokensByAccountRequest : public ProtobufCppMessage
+{
+  CAuthenticationSupportQueryRefreshTokensByAccountRequest() :
+     ProtobufCppMessage(cauthentication_support__query_refresh_tokens_by_account__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  protobuf_c_boolean has_include_revoked_tokens;
+  protobuf_c_boolean include_revoked_tokens;
+};
+
+struct CSupportRefreshTokenDescription__TokenUsageEvent : public ProtobufCppMessage
+{
+  CSupportRefreshTokenDescription__TokenUsageEvent() :
+     ProtobufCppMessage(csupport_refresh_token_description__token_usage_event__descriptor)
+  {}
+
+  protobuf_c_boolean has_time;
+  uint32_t time;
+  CMsgIPAddress *ip;
+  char *country;
+  char *state;
+  char *city;
+};
+
+struct CSupportRefreshTokenDescription : public ProtobufCppMessage
+{
+  CSupportRefreshTokenDescription() :
+     ProtobufCppMessage(csupport_refresh_token_description__descriptor)
+  {}
+
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+  char *token_description;
+  protobuf_c_boolean has_time_updated;
+  uint32_t time_updated;
+  protobuf_c_boolean has_platform_type;
+  EAuthTokenPlatformType platform_type;
+  protobuf_c_boolean has_token_state;
+  EAuthTokenState token_state;
+  protobuf_c_boolean has_owner_steamid;
+  uint64_t owner_steamid;
+  protobuf_c_boolean has_os_platform;
+  uint32_t os_platform;
+  protobuf_c_boolean has_os_type;
+  int32_t os_type;
+  protobuf_c_boolean has_auth_type;
+  uint32_t auth_type;
+  protobuf_c_boolean has_gaming_device_type;
+  uint32_t gaming_device_type;
+  CSupportRefreshTokenDescription__TokenUsageEvent *first_seen;
+  CSupportRefreshTokenDescription__TokenUsageEvent *last_seen;
+};
+
+struct CAuthenticationSupportQueryRefreshTokensByAccountResponse : public ProtobufCppMessage
+{
+  CAuthenticationSupportQueryRefreshTokensByAccountResponse() :
+     ProtobufCppMessage(cauthentication_support__query_refresh_tokens_by_account__response__descriptor)
+  {}
+
+  size_t n_refresh_tokens;
+  CSupportRefreshTokenDescription **refresh_tokens;
+  protobuf_c_boolean has_last_token_reset;
+  int32_t last_token_reset;
+};
+
+struct CAuthenticationSupportQueryRefreshTokenByIDRequest : public ProtobufCppMessage
+{
+  CAuthenticationSupportQueryRefreshTokenByIDRequest() :
+     ProtobufCppMessage(cauthentication_support__query_refresh_token_by_id__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+};
+
+struct CAuthenticationSupportQueryRefreshTokenByIDResponse : public ProtobufCppMessage
+{
+  CAuthenticationSupportQueryRefreshTokenByIDResponse() :
+     ProtobufCppMessage(cauthentication_support__query_refresh_token_by_id__response__descriptor)
+  {}
+
+  size_t n_refresh_tokens;
+  CSupportRefreshTokenDescription **refresh_tokens;
+};
+
+struct CAuthenticationSupportRevokeTokenRequest : public ProtobufCppMessage
+{
+  CAuthenticationSupportRevokeTokenRequest() :
+     ProtobufCppMessage(cauthentication_support__revoke_token__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+};
+
+struct CAuthenticationSupportRevokeTokenResponse : public ProtobufCppMessage
+{
+  CAuthenticationSupportRevokeTokenResponse() :
+     ProtobufCppMessage(cauthentication_support__revoke_token__response__descriptor)
+  {}
+
+};
+
+struct CAuthenticationSupportGetTokenHistoryRequest : public ProtobufCppMessage
+{
+  CAuthenticationSupportGetTokenHistoryRequest() :
+     ProtobufCppMessage(cauthentication_support__get_token_history__request__descriptor)
+  {}
+
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+};
+
+struct CSupportRefreshTokenAudit : public ProtobufCppMessage
+{
+  CSupportRefreshTokenAudit() :
+     ProtobufCppMessage(csupport_refresh_token_audit__descriptor)
+  {}
+
+  protobuf_c_boolean has_action;
+  int32_t action;
+  protobuf_c_boolean has_time;
+  uint32_t time;
+  CMsgIPAddress *ip;
+  protobuf_c_boolean has_actor;
+  uint64_t actor;
+};
+
+struct CAuthenticationSupportGetTokenHistoryResponse : public ProtobufCppMessage
+{
+  CAuthenticationSupportGetTokenHistoryResponse() :
+     ProtobufCppMessage(cauthentication_support__get_token_history__response__descriptor)
+  {}
+
+  size_t n_history;
+  CSupportRefreshTokenAudit **history;
+};
+
+struct CCloudGamingCreateNonceRequest : public ProtobufCppMessage
+{
+  CCloudGamingCreateNonceRequest() :
+     ProtobufCppMessage(ccloud_gaming__create_nonce__request__descriptor)
+  {}
+
+  char *platform;
+  protobuf_c_boolean has_appid;
+  uint32_t appid;
+};
+
+struct CCloudGamingCreateNonceResponse : public ProtobufCppMessage
+{
+  CCloudGamingCreateNonceResponse() :
+     ProtobufCppMessage(ccloud_gaming__create_nonce__response__descriptor)
+  {}
+
+  char *nonce;
+  protobuf_c_boolean has_expiry;
+  uint32_t expiry;
+};
+
+struct CCloudGamingGetTimeRemainingRequest : public ProtobufCppMessage
+{
+  CCloudGamingGetTimeRemainingRequest() :
+     ProtobufCppMessage(ccloud_gaming__get_time_remaining__request__descriptor)
+  {}
+
+  char *platform;
+  size_t n_appid_list;
+  uint32_t *appid_list;
+};
+
+struct CCloudGamingTimeRemaining : public ProtobufCppMessage
+{
+  CCloudGamingTimeRemaining() :
+     ProtobufCppMessage(ccloud_gaming__time_remaining__descriptor)
+  {}
+
+  protobuf_c_boolean has_appid;
+  uint32_t appid;
+  protobuf_c_boolean has_minutes_remaining;
+  uint32_t minutes_remaining;
+};
+
+struct CCloudGamingGetTimeRemainingResponse : public ProtobufCppMessage
+{
+  CCloudGamingGetTimeRemainingResponse() :
+     ProtobufCppMessage(ccloud_gaming__get_time_remaining__response__descriptor)
+  {}
+
+  size_t n_entries;
+  CCloudGamingTimeRemaining **entries;
+};
+
+size_t cauthentication__get_password_rsapublic_key__request__get_packed_size
+                     (const CAuthenticationGetPasswordRSAPublicKeyRequest   *message);
+size_t cauthentication__get_password_rsapublic_key__request__pack
+                     (const CAuthenticationGetPasswordRSAPublicKeyRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__get_password_rsapublic_key__request__pack_to_buffer
+                     (const CAuthenticationGetPasswordRSAPublicKeyRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationGetPasswordRSAPublicKeyRequest *
+       cauthentication__get_password_rsapublic_key__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__get_password_rsapublic_key__request__free_unpacked
+                     (CAuthenticationGetPasswordRSAPublicKeyRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__get_password_rsapublic_key__response__get_packed_size
+                     (const CAuthenticationGetPasswordRSAPublicKeyResponse   *message);
+size_t cauthentication__get_password_rsapublic_key__response__pack
+                     (const CAuthenticationGetPasswordRSAPublicKeyResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__get_password_rsapublic_key__response__pack_to_buffer
+                     (const CAuthenticationGetPasswordRSAPublicKeyResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationGetPasswordRSAPublicKeyResponse *
+       cauthentication__get_password_rsapublic_key__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__get_password_rsapublic_key__response__free_unpacked
+                     (CAuthenticationGetPasswordRSAPublicKeyResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__device_details__get_packed_size
+                     (const CAuthenticationDeviceDetails   *message);
+size_t cauthentication__device_details__pack
+                     (const CAuthenticationDeviceDetails   *message,
+                      uint8_t             *out);
+size_t cauthentication__device_details__pack_to_buffer
+                     (const CAuthenticationDeviceDetails   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationDeviceDetails *
+       cauthentication__device_details__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__device_details__free_unpacked
+                     (CAuthenticationDeviceDetails *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__begin_auth_session_via_qr__request__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaQRRequest   *message);
+size_t cauthentication__begin_auth_session_via_qr__request__pack
+                     (const CAuthenticationBeginAuthSessionViaQRRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__begin_auth_session_via_qr__request__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaQRRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationBeginAuthSessionViaQRRequest *
+       cauthentication__begin_auth_session_via_qr__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__begin_auth_session_via_qr__request__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaQRRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__allowed_confirmation__get_packed_size
+                     (const CAuthenticationAllowedConfirmation   *message);
+size_t cauthentication__allowed_confirmation__pack
+                     (const CAuthenticationAllowedConfirmation   *message,
+                      uint8_t             *out);
+size_t cauthentication__allowed_confirmation__pack_to_buffer
+                     (const CAuthenticationAllowedConfirmation   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationAllowedConfirmation *
+       cauthentication__allowed_confirmation__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__allowed_confirmation__free_unpacked
+                     (CAuthenticationAllowedConfirmation *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__begin_auth_session_via_qr__response__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaQRResponse   *message);
+size_t cauthentication__begin_auth_session_via_qr__response__pack
+                     (const CAuthenticationBeginAuthSessionViaQRResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__begin_auth_session_via_qr__response__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaQRResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationBeginAuthSessionViaQRResponse *
+       cauthentication__begin_auth_session_via_qr__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__begin_auth_session_via_qr__response__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaQRResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__begin_auth_session_via_credentials__request__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaCredentialsRequest   *message);
+size_t cauthentication__begin_auth_session_via_credentials__request__pack
+                     (const CAuthenticationBeginAuthSessionViaCredentialsRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__begin_auth_session_via_credentials__request__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaCredentialsRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationBeginAuthSessionViaCredentialsRequest *
+       cauthentication__begin_auth_session_via_credentials__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__begin_auth_session_via_credentials__request__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaCredentialsRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__begin_auth_session_via_credentials__response__get_packed_size
+                     (const CAuthenticationBeginAuthSessionViaCredentialsResponse   *message);
+size_t cauthentication__begin_auth_session_via_credentials__response__pack
+                     (const CAuthenticationBeginAuthSessionViaCredentialsResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__begin_auth_session_via_credentials__response__pack_to_buffer
+                     (const CAuthenticationBeginAuthSessionViaCredentialsResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationBeginAuthSessionViaCredentialsResponse *
+       cauthentication__begin_auth_session_via_credentials__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__begin_auth_session_via_credentials__response__free_unpacked
+                     (CAuthenticationBeginAuthSessionViaCredentialsResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__poll_auth_session_status__request__get_packed_size
+                     (const CAuthenticationPollAuthSessionStatusRequest   *message);
+size_t cauthentication__poll_auth_session_status__request__pack
+                     (const CAuthenticationPollAuthSessionStatusRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__poll_auth_session_status__request__pack_to_buffer
+                     (const CAuthenticationPollAuthSessionStatusRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationPollAuthSessionStatusRequest *
+       cauthentication__poll_auth_session_status__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__poll_auth_session_status__request__free_unpacked
+                     (CAuthenticationPollAuthSessionStatusRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__poll_auth_session_status__response__get_packed_size
+                     (const CAuthenticationPollAuthSessionStatusResponse   *message);
+size_t cauthentication__poll_auth_session_status__response__pack
+                     (const CAuthenticationPollAuthSessionStatusResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__poll_auth_session_status__response__pack_to_buffer
+                     (const CAuthenticationPollAuthSessionStatusResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationPollAuthSessionStatusResponse *
+       cauthentication__poll_auth_session_status__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__poll_auth_session_status__response__free_unpacked
+                     (CAuthenticationPollAuthSessionStatusResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__get_auth_session_info__request__get_packed_size
+                     (const CAuthenticationGetAuthSessionInfoRequest   *message);
+size_t cauthentication__get_auth_session_info__request__pack
+                     (const CAuthenticationGetAuthSessionInfoRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__get_auth_session_info__request__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionInfoRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationGetAuthSessionInfoRequest *
+       cauthentication__get_auth_session_info__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__get_auth_session_info__request__free_unpacked
+                     (CAuthenticationGetAuthSessionInfoRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__get_auth_session_info__response__get_packed_size
+                     (const CAuthenticationGetAuthSessionInfoResponse   *message);
+size_t cauthentication__get_auth_session_info__response__pack
+                     (const CAuthenticationGetAuthSessionInfoResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__get_auth_session_info__response__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionInfoResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationGetAuthSessionInfoResponse *
+       cauthentication__get_auth_session_info__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__get_auth_session_info__response__free_unpacked
+                     (CAuthenticationGetAuthSessionInfoResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__update_auth_session_with_mobile_confirmation__request__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest   *message);
+size_t cauthentication__update_auth_session_with_mobile_confirmation__request__pack
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__update_auth_session_with_mobile_confirmation__request__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *
+       cauthentication__update_auth_session_with_mobile_confirmation__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__update_auth_session_with_mobile_confirmation__request__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__update_auth_session_with_mobile_confirmation__response__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse   *message);
+size_t cauthentication__update_auth_session_with_mobile_confirmation__response__pack
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__update_auth_session_with_mobile_confirmation__response__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *
+       cauthentication__update_auth_session_with_mobile_confirmation__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__update_auth_session_with_mobile_confirmation__response__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__update_auth_session_with_steam_guard_code__request__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest   *message);
+size_t cauthentication__update_auth_session_with_steam_guard_code__request__pack
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__update_auth_session_with_steam_guard_code__request__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *
+       cauthentication__update_auth_session_with_steam_guard_code__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__update_auth_session_with_steam_guard_code__request__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__update_auth_session_with_steam_guard_code__response__get_packed_size
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse   *message);
+size_t cauthentication__update_auth_session_with_steam_guard_code__response__pack
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__update_auth_session_with_steam_guard_code__response__pack_to_buffer
+                     (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *
+       cauthentication__update_auth_session_with_steam_guard_code__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__update_auth_session_with_steam_guard_code__response__free_unpacked
+                     (CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__access_token__generate_for_app__request__get_packed_size
+                     (const CAuthenticationAccessTokenGenerateForAppRequest   *message);
+size_t cauthentication__access_token__generate_for_app__request__pack
+                     (const CAuthenticationAccessTokenGenerateForAppRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__access_token__generate_for_app__request__pack_to_buffer
+                     (const CAuthenticationAccessTokenGenerateForAppRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationAccessTokenGenerateForAppRequest *
+       cauthentication__access_token__generate_for_app__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__access_token__generate_for_app__request__free_unpacked
+                     (CAuthenticationAccessTokenGenerateForAppRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__access_token__generate_for_app__response__get_packed_size
+                     (const CAuthenticationAccessTokenGenerateForAppResponse   *message);
+size_t cauthentication__access_token__generate_for_app__response__pack
+                     (const CAuthenticationAccessTokenGenerateForAppResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__access_token__generate_for_app__response__pack_to_buffer
+                     (const CAuthenticationAccessTokenGenerateForAppResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationAccessTokenGenerateForAppResponse *
+       cauthentication__access_token__generate_for_app__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__access_token__generate_for_app__response__free_unpacked
+                     (CAuthenticationAccessTokenGenerateForAppResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__refresh_token__enumerate__request__get_packed_size
+                     (const CAuthenticationRefreshTokenEnumerateRequest   *message);
+size_t cauthentication__refresh_token__enumerate__request__pack
+                     (const CAuthenticationRefreshTokenEnumerateRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__refresh_token__enumerate__request__pack_to_buffer
+                     (const CAuthenticationRefreshTokenEnumerateRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationRefreshTokenEnumerateRequest *
+       cauthentication__refresh_token__enumerate__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__refresh_token__enumerate__request__free_unpacked
+                     (CAuthenticationRefreshTokenEnumerateRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__refresh_token__enumerate__response__get_packed_size
+                     (const CAuthenticationRefreshTokenEnumerateResponse   *message);
+size_t cauthentication__refresh_token__enumerate__response__pack
+                     (const CAuthenticationRefreshTokenEnumerateResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__refresh_token__enumerate__response__pack_to_buffer
+                     (const CAuthenticationRefreshTokenEnumerateResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationRefreshTokenEnumerateResponse *
+       cauthentication__refresh_token__enumerate__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__refresh_token__enumerate__response__free_unpacked
+                     (CAuthenticationRefreshTokenEnumerateResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__get_auth_sessions_for_account__request__get_packed_size
+                     (const CAuthenticationGetAuthSessionsForAccountRequest   *message);
+size_t cauthentication__get_auth_sessions_for_account__request__pack
+                     (const CAuthenticationGetAuthSessionsForAccountRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__get_auth_sessions_for_account__request__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionsForAccountRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationGetAuthSessionsForAccountRequest *
+       cauthentication__get_auth_sessions_for_account__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__get_auth_sessions_for_account__request__free_unpacked
+                     (CAuthenticationGetAuthSessionsForAccountRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__get_auth_sessions_for_account__response__get_packed_size
+                     (const CAuthenticationGetAuthSessionsForAccountResponse   *message);
+size_t cauthentication__get_auth_sessions_for_account__response__pack
+                     (const CAuthenticationGetAuthSessionsForAccountResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__get_auth_sessions_for_account__response__pack_to_buffer
+                     (const CAuthenticationGetAuthSessionsForAccountResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationGetAuthSessionsForAccountResponse *
+       cauthentication__get_auth_sessions_for_account__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__get_auth_sessions_for_account__response__free_unpacked
+                     (CAuthenticationGetAuthSessionsForAccountResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__migrate_mobile_session__request__get_packed_size
+                     (const CAuthenticationMigrateMobileSessionRequest   *message);
+size_t cauthentication__migrate_mobile_session__request__pack
+                     (const CAuthenticationMigrateMobileSessionRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__migrate_mobile_session__request__pack_to_buffer
+                     (const CAuthenticationMigrateMobileSessionRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationMigrateMobileSessionRequest *
+       cauthentication__migrate_mobile_session__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__migrate_mobile_session__request__free_unpacked
+                     (CAuthenticationMigrateMobileSessionRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__migrate_mobile_session__response__get_packed_size
+                     (const CAuthenticationMigrateMobileSessionResponse   *message);
+size_t cauthentication__migrate_mobile_session__response__pack
+                     (const CAuthenticationMigrateMobileSessionResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__migrate_mobile_session__response__pack_to_buffer
+                     (const CAuthenticationMigrateMobileSessionResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationMigrateMobileSessionResponse *
+       cauthentication__migrate_mobile_session__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__migrate_mobile_session__response__free_unpacked
+                     (CAuthenticationMigrateMobileSessionResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__refresh_token__revoke__request__get_packed_size
+                     (const CAuthenticationRefreshTokenRevokeRequest   *message);
+size_t cauthentication__refresh_token__revoke__request__pack
+                     (const CAuthenticationRefreshTokenRevokeRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication__refresh_token__revoke__request__pack_to_buffer
+                     (const CAuthenticationRefreshTokenRevokeRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationRefreshTokenRevokeRequest *
+       cauthentication__refresh_token__revoke__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__refresh_token__revoke__request__free_unpacked
+                     (CAuthenticationRefreshTokenRevokeRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication__refresh_token__revoke__response__get_packed_size
+                     (const CAuthenticationRefreshTokenRevokeResponse   *message);
+size_t cauthentication__refresh_token__revoke__response__pack
+                     (const CAuthenticationRefreshTokenRevokeResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication__refresh_token__revoke__response__pack_to_buffer
+                     (const CAuthenticationRefreshTokenRevokeResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationRefreshTokenRevokeResponse *
+       cauthentication__refresh_token__revoke__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication__refresh_token__revoke__response__free_unpacked
+                     (CAuthenticationRefreshTokenRevokeResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__query_refresh_tokens_by_account__request__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountRequest   *message);
+size_t cauthentication_support__query_refresh_tokens_by_account__request__pack
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__query_refresh_tokens_by_account__request__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportQueryRefreshTokensByAccountRequest *
+       cauthentication_support__query_refresh_tokens_by_account__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__query_refresh_tokens_by_account__request__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokensByAccountRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t csupport_refresh_token_description__get_packed_size
+                     (const CSupportRefreshTokenDescription   *message);
+size_t csupport_refresh_token_description__pack
+                     (const CSupportRefreshTokenDescription   *message,
+                      uint8_t             *out);
+size_t csupport_refresh_token_description__pack_to_buffer
+                     (const CSupportRefreshTokenDescription   *message,
+                      ProtobufCBuffer     *buffer);
+CSupportRefreshTokenDescription *
+       csupport_refresh_token_description__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   csupport_refresh_token_description__free_unpacked
+                     (CSupportRefreshTokenDescription *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__query_refresh_tokens_by_account__response__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountResponse   *message);
+size_t cauthentication_support__query_refresh_tokens_by_account__response__pack
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__query_refresh_tokens_by_account__response__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokensByAccountResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportQueryRefreshTokensByAccountResponse *
+       cauthentication_support__query_refresh_tokens_by_account__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__query_refresh_tokens_by_account__response__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokensByAccountResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__query_refresh_token_by_id__request__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokenByIDRequest   *message);
+size_t cauthentication_support__query_refresh_token_by_id__request__pack
+                     (const CAuthenticationSupportQueryRefreshTokenByIDRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__query_refresh_token_by_id__request__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokenByIDRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportQueryRefreshTokenByIDRequest *
+       cauthentication_support__query_refresh_token_by_id__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__query_refresh_token_by_id__request__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokenByIDRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__query_refresh_token_by_id__response__get_packed_size
+                     (const CAuthenticationSupportQueryRefreshTokenByIDResponse   *message);
+size_t cauthentication_support__query_refresh_token_by_id__response__pack
+                     (const CAuthenticationSupportQueryRefreshTokenByIDResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__query_refresh_token_by_id__response__pack_to_buffer
+                     (const CAuthenticationSupportQueryRefreshTokenByIDResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportQueryRefreshTokenByIDResponse *
+       cauthentication_support__query_refresh_token_by_id__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__query_refresh_token_by_id__response__free_unpacked
+                     (CAuthenticationSupportQueryRefreshTokenByIDResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__revoke_token__request__get_packed_size
+                     (const CAuthenticationSupportRevokeTokenRequest   *message);
+size_t cauthentication_support__revoke_token__request__pack
+                     (const CAuthenticationSupportRevokeTokenRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__revoke_token__request__pack_to_buffer
+                     (const CAuthenticationSupportRevokeTokenRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportRevokeTokenRequest *
+       cauthentication_support__revoke_token__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__revoke_token__request__free_unpacked
+                     (CAuthenticationSupportRevokeTokenRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__revoke_token__response__get_packed_size
+                     (const CAuthenticationSupportRevokeTokenResponse   *message);
+size_t cauthentication_support__revoke_token__response__pack
+                     (const CAuthenticationSupportRevokeTokenResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__revoke_token__response__pack_to_buffer
+                     (const CAuthenticationSupportRevokeTokenResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportRevokeTokenResponse *
+       cauthentication_support__revoke_token__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__revoke_token__response__free_unpacked
+                     (CAuthenticationSupportRevokeTokenResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__get_token_history__request__get_packed_size
+                     (const CAuthenticationSupportGetTokenHistoryRequest   *message);
+size_t cauthentication_support__get_token_history__request__pack
+                     (const CAuthenticationSupportGetTokenHistoryRequest   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__get_token_history__request__pack_to_buffer
+                     (const CAuthenticationSupportGetTokenHistoryRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportGetTokenHistoryRequest *
+       cauthentication_support__get_token_history__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__get_token_history__request__free_unpacked
+                     (CAuthenticationSupportGetTokenHistoryRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t csupport_refresh_token_audit__get_packed_size
+                     (const CSupportRefreshTokenAudit   *message);
+size_t csupport_refresh_token_audit__pack
+                     (const CSupportRefreshTokenAudit   *message,
+                      uint8_t             *out);
+size_t csupport_refresh_token_audit__pack_to_buffer
+                     (const CSupportRefreshTokenAudit   *message,
+                      ProtobufCBuffer     *buffer);
+CSupportRefreshTokenAudit *
+       csupport_refresh_token_audit__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   csupport_refresh_token_audit__free_unpacked
+                     (CSupportRefreshTokenAudit *message,
+                      ProtobufCAllocator *allocator);
+size_t cauthentication_support__get_token_history__response__get_packed_size
+                     (const CAuthenticationSupportGetTokenHistoryResponse   *message);
+size_t cauthentication_support__get_token_history__response__pack
+                     (const CAuthenticationSupportGetTokenHistoryResponse   *message,
+                      uint8_t             *out);
+size_t cauthentication_support__get_token_history__response__pack_to_buffer
+                     (const CAuthenticationSupportGetTokenHistoryResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CAuthenticationSupportGetTokenHistoryResponse *
+       cauthentication_support__get_token_history__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cauthentication_support__get_token_history__response__free_unpacked
+                     (CAuthenticationSupportGetTokenHistoryResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t ccloud_gaming__create_nonce__request__get_packed_size
+                     (const CCloudGamingCreateNonceRequest   *message);
+size_t ccloud_gaming__create_nonce__request__pack
+                     (const CCloudGamingCreateNonceRequest   *message,
+                      uint8_t             *out);
+size_t ccloud_gaming__create_nonce__request__pack_to_buffer
+                     (const CCloudGamingCreateNonceRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CCloudGamingCreateNonceRequest *
+       ccloud_gaming__create_nonce__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccloud_gaming__create_nonce__request__free_unpacked
+                     (CCloudGamingCreateNonceRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t ccloud_gaming__create_nonce__response__get_packed_size
+                     (const CCloudGamingCreateNonceResponse   *message);
+size_t ccloud_gaming__create_nonce__response__pack
+                     (const CCloudGamingCreateNonceResponse   *message,
+                      uint8_t             *out);
+size_t ccloud_gaming__create_nonce__response__pack_to_buffer
+                     (const CCloudGamingCreateNonceResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CCloudGamingCreateNonceResponse *
+       ccloud_gaming__create_nonce__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccloud_gaming__create_nonce__response__free_unpacked
+                     (CCloudGamingCreateNonceResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t ccloud_gaming__get_time_remaining__request__get_packed_size
+                     (const CCloudGamingGetTimeRemainingRequest   *message);
+size_t ccloud_gaming__get_time_remaining__request__pack
+                     (const CCloudGamingGetTimeRemainingRequest   *message,
+                      uint8_t             *out);
+size_t ccloud_gaming__get_time_remaining__request__pack_to_buffer
+                     (const CCloudGamingGetTimeRemainingRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CCloudGamingGetTimeRemainingRequest *
+       ccloud_gaming__get_time_remaining__request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccloud_gaming__get_time_remaining__request__free_unpacked
+                     (CCloudGamingGetTimeRemainingRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t ccloud_gaming__time_remaining__get_packed_size
+                     (const CCloudGamingTimeRemaining   *message);
+size_t ccloud_gaming__time_remaining__pack
+                     (const CCloudGamingTimeRemaining   *message,
+                      uint8_t             *out);
+size_t ccloud_gaming__time_remaining__pack_to_buffer
+                     (const CCloudGamingTimeRemaining   *message,
+                      ProtobufCBuffer     *buffer);
+CCloudGamingTimeRemaining *
+       ccloud_gaming__time_remaining__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccloud_gaming__time_remaining__free_unpacked
+                     (CCloudGamingTimeRemaining *message,
+                      ProtobufCAllocator *allocator);
+size_t ccloud_gaming__get_time_remaining__response__get_packed_size
+                     (const CCloudGamingGetTimeRemainingResponse   *message);
+size_t ccloud_gaming__get_time_remaining__response__pack
+                     (const CCloudGamingGetTimeRemainingResponse   *message,
+                      uint8_t             *out);
+size_t ccloud_gaming__get_time_remaining__response__pack_to_buffer
+                     (const CCloudGamingGetTimeRemainingResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CCloudGamingGetTimeRemainingResponse *
+       ccloud_gaming__get_time_remaining__response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccloud_gaming__get_time_remaining__response__free_unpacked
+                     (CCloudGamingGetTimeRemainingResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*CAuthenticationGetPasswordRSAPublicKeyRequest_Closure)
+                 (const CAuthenticationGetPasswordRSAPublicKeyRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationGetPasswordRSAPublicKeyResponse_Closure)
+                 (const CAuthenticationGetPasswordRSAPublicKeyResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationDeviceDetails_Closure)
+                 (const CAuthenticationDeviceDetails *message,
+                  void *closure_data);
+typedef void (*CAuthenticationBeginAuthSessionViaQRRequest_Closure)
+                 (const CAuthenticationBeginAuthSessionViaQRRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationAllowedConfirmation_Closure)
+                 (const CAuthenticationAllowedConfirmation *message,
+                  void *closure_data);
+typedef void (*CAuthenticationBeginAuthSessionViaQRResponse_Closure)
+                 (const CAuthenticationBeginAuthSessionViaQRResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationBeginAuthSessionViaCredentialsRequest_Closure)
+                 (const CAuthenticationBeginAuthSessionViaCredentialsRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationBeginAuthSessionViaCredentialsResponse_Closure)
+                 (const CAuthenticationBeginAuthSessionViaCredentialsResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationPollAuthSessionStatusRequest_Closure)
+                 (const CAuthenticationPollAuthSessionStatusRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationPollAuthSessionStatusResponse_Closure)
+                 (const CAuthenticationPollAuthSessionStatusResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationGetAuthSessionInfoRequest_Closure)
+                 (const CAuthenticationGetAuthSessionInfoRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationGetAuthSessionInfoResponse_Closure)
+                 (const CAuthenticationGetAuthSessionInfoResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest_Closure)
+                 (const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse_Closure)
+                 (const CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest_Closure)
+                 (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse_Closure)
+                 (const CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationAccessTokenGenerateForAppRequest_Closure)
+                 (const CAuthenticationAccessTokenGenerateForAppRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationAccessTokenGenerateForAppResponse_Closure)
+                 (const CAuthenticationAccessTokenGenerateForAppResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationRefreshTokenEnumerateRequest_Closure)
+                 (const CAuthenticationRefreshTokenEnumerateRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent_Closure)
+                 (const CAuthenticationRefreshTokenEnumerateResponse__TokenUsageEvent *message,
+                  void *closure_data);
+typedef void (*CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription_Closure)
+                 (const CAuthenticationRefreshTokenEnumerateResponse__RefreshTokenDescription *message,
+                  void *closure_data);
+typedef void (*CAuthenticationRefreshTokenEnumerateResponse_Closure)
+                 (const CAuthenticationRefreshTokenEnumerateResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationGetAuthSessionsForAccountRequest_Closure)
+                 (const CAuthenticationGetAuthSessionsForAccountRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationGetAuthSessionsForAccountResponse_Closure)
+                 (const CAuthenticationGetAuthSessionsForAccountResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationMigrateMobileSessionRequest_Closure)
+                 (const CAuthenticationMigrateMobileSessionRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationMigrateMobileSessionResponse_Closure)
+                 (const CAuthenticationMigrateMobileSessionResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationRefreshTokenRevokeRequest_Closure)
+                 (const CAuthenticationRefreshTokenRevokeRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationRefreshTokenRevokeResponse_Closure)
+                 (const CAuthenticationRefreshTokenRevokeResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportQueryRefreshTokensByAccountRequest_Closure)
+                 (const CAuthenticationSupportQueryRefreshTokensByAccountRequest *message,
+                  void *closure_data);
+typedef void (*CSupportRefreshTokenDescription__TokenUsageEvent_Closure)
+                 (const CSupportRefreshTokenDescription__TokenUsageEvent *message,
+                  void *closure_data);
+typedef void (*CSupportRefreshTokenDescription_Closure)
+                 (const CSupportRefreshTokenDescription *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportQueryRefreshTokensByAccountResponse_Closure)
+                 (const CAuthenticationSupportQueryRefreshTokensByAccountResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportQueryRefreshTokenByIDRequest_Closure)
+                 (const CAuthenticationSupportQueryRefreshTokenByIDRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportQueryRefreshTokenByIDResponse_Closure)
+                 (const CAuthenticationSupportQueryRefreshTokenByIDResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportRevokeTokenRequest_Closure)
+                 (const CAuthenticationSupportRevokeTokenRequest *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportRevokeTokenResponse_Closure)
+                 (const CAuthenticationSupportRevokeTokenResponse *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportGetTokenHistoryRequest_Closure)
+                 (const CAuthenticationSupportGetTokenHistoryRequest *message,
+                  void *closure_data);
+typedef void (*CSupportRefreshTokenAudit_Closure)
+                 (const CSupportRefreshTokenAudit *message,
+                  void *closure_data);
+typedef void (*CAuthenticationSupportGetTokenHistoryResponse_Closure)
+                 (const CAuthenticationSupportGetTokenHistoryResponse *message,
+                  void *closure_data);
+typedef void (*CCloudGamingCreateNonceRequest_Closure)
+                 (const CCloudGamingCreateNonceRequest *message,
+                  void *closure_data);
+typedef void (*CCloudGamingCreateNonceResponse_Closure)
+                 (const CCloudGamingCreateNonceResponse *message,
+                  void *closure_data);
+typedef void (*CCloudGamingGetTimeRemainingRequest_Closure)
+                 (const CCloudGamingGetTimeRemainingRequest *message,
+                  void *closure_data);
+typedef void (*CCloudGamingTimeRemaining_Closure)
+                 (const CCloudGamingTimeRemaining *message,
+                  void *closure_data);
+typedef void (*CCloudGamingGetTimeRemainingResponse_Closure)
+                 (const CCloudGamingGetTimeRemainingResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+typedef struct Authentication_Service Authentication_Service;
+struct Authentication_Service
+{
+  ProtobufCService base;
+  void (*get_password_rsapublic_key)(Authentication_Service *service,
+                                     const CAuthenticationGetPasswordRSAPublicKeyRequest *input,
+                                     CAuthenticationGetPasswordRSAPublicKeyResponse_Closure closure,
+                                     void *closure_data);
+  void (*begin_auth_session_via_qr)(Authentication_Service *service,
+                                    const CAuthenticationBeginAuthSessionViaQRRequest *input,
+                                    CAuthenticationBeginAuthSessionViaQRResponse_Closure closure,
+                                    void *closure_data);
+  void (*begin_auth_session_via_credentials)(Authentication_Service *service,
+                                             const CAuthenticationBeginAuthSessionViaCredentialsRequest *input,
+                                             CAuthenticationBeginAuthSessionViaCredentialsResponse_Closure closure,
+                                             void *closure_data);
+  void (*poll_auth_session_status)(Authentication_Service *service,
+                                   const CAuthenticationPollAuthSessionStatusRequest *input,
+                                   CAuthenticationPollAuthSessionStatusResponse_Closure closure,
+                                   void *closure_data);
+  void (*get_auth_session_info)(Authentication_Service *service,
+                                const CAuthenticationGetAuthSessionInfoRequest *input,
+                                CAuthenticationGetAuthSessionInfoResponse_Closure closure,
+                                void *closure_data);
+  void (*update_auth_session_with_mobile_confirmation)(Authentication_Service *service,
+                                                       const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *input,
+                                                       CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse_Closure closure,
+                                                       void *closure_data);
+  void (*update_auth_session_with_steam_guard_code)(Authentication_Service *service,
+                                                    const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *input,
+                                                    CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse_Closure closure,
+                                                    void *closure_data);
+  void (*generate_access_token_for_app)(Authentication_Service *service,
+                                        const CAuthenticationAccessTokenGenerateForAppRequest *input,
+                                        CAuthenticationAccessTokenGenerateForAppResponse_Closure closure,
+                                        void *closure_data);
+  void (*enumerate_tokens)(Authentication_Service *service,
+                           const CAuthenticationRefreshTokenEnumerateRequest *input,
+                           CAuthenticationRefreshTokenEnumerateResponse_Closure closure,
+                           void *closure_data);
+  void (*get_auth_sessions_for_account)(Authentication_Service *service,
+                                        const CAuthenticationGetAuthSessionsForAccountRequest *input,
+                                        CAuthenticationGetAuthSessionsForAccountResponse_Closure closure,
+                                        void *closure_data);
+  void (*migrate_mobile_session)(Authentication_Service *service,
+                                 const CAuthenticationMigrateMobileSessionRequest *input,
+                                 CAuthenticationMigrateMobileSessionResponse_Closure closure,
+                                 void *closure_data);
+  void (*revoke_refresh_token)(Authentication_Service *service,
+                               const CAuthenticationRefreshTokenRevokeRequest *input,
+                               CAuthenticationRefreshTokenRevokeResponse_Closure closure,
+                               void *closure_data);
+};
+typedef void (*Authentication_ServiceDestroy)(Authentication_Service *);
+void authentication__init (Authentication_Service *service,
+                           Authentication_ServiceDestroy destroy);
+#define AUTHENTICATION__BASE_INIT \
+    { &authentication__descriptor, protobuf_c_service_invoke_internal, NULL }
+#define AUTHENTICATION__INIT(function_prefix__) \
+    { AUTHENTICATION__BASE_INIT,\
+      function_prefix__ ## get_password_rsapublic_key,\
+      function_prefix__ ## begin_auth_session_via_qr,\
+      function_prefix__ ## begin_auth_session_via_credentials,\
+      function_prefix__ ## poll_auth_session_status,\
+      function_prefix__ ## get_auth_session_info,\
+      function_prefix__ ## update_auth_session_with_mobile_confirmation,\
+      function_prefix__ ## update_auth_session_with_steam_guard_code,\
+      function_prefix__ ## generate_access_token_for_app,\
+      function_prefix__ ## enumerate_tokens,\
+      function_prefix__ ## get_auth_sessions_for_account,\
+      function_prefix__ ## migrate_mobile_session,\
+      function_prefix__ ## revoke_refresh_token  }
+void authentication__get_password_rsapublic_key(ProtobufCService *service,
+                                                const CAuthenticationGetPasswordRSAPublicKeyRequest *input,
+                                                CAuthenticationGetPasswordRSAPublicKeyResponse_Closure closure,
+                                                void *closure_data);
+void authentication__begin_auth_session_via_qr(ProtobufCService *service,
+                                               const CAuthenticationBeginAuthSessionViaQRRequest *input,
+                                               CAuthenticationBeginAuthSessionViaQRResponse_Closure closure,
+                                               void *closure_data);
+void authentication__begin_auth_session_via_credentials(ProtobufCService *service,
+                                                        const CAuthenticationBeginAuthSessionViaCredentialsRequest *input,
+                                                        CAuthenticationBeginAuthSessionViaCredentialsResponse_Closure closure,
+                                                        void *closure_data);
+void authentication__poll_auth_session_status(ProtobufCService *service,
+                                              const CAuthenticationPollAuthSessionStatusRequest *input,
+                                              CAuthenticationPollAuthSessionStatusResponse_Closure closure,
+                                              void *closure_data);
+void authentication__get_auth_session_info(ProtobufCService *service,
+                                           const CAuthenticationGetAuthSessionInfoRequest *input,
+                                           CAuthenticationGetAuthSessionInfoResponse_Closure closure,
+                                           void *closure_data);
+void authentication__update_auth_session_with_mobile_confirmation(ProtobufCService *service,
+                                                                  const CAuthenticationUpdateAuthSessionWithMobileConfirmationRequest *input,
+                                                                  CAuthenticationUpdateAuthSessionWithMobileConfirmationResponse_Closure closure,
+                                                                  void *closure_data);
+void authentication__update_auth_session_with_steam_guard_code(ProtobufCService *service,
+                                                               const CAuthenticationUpdateAuthSessionWithSteamGuardCodeRequest *input,
+                                                               CAuthenticationUpdateAuthSessionWithSteamGuardCodeResponse_Closure closure,
+                                                               void *closure_data);
+void authentication__generate_access_token_for_app(ProtobufCService *service,
+                                                   const CAuthenticationAccessTokenGenerateForAppRequest *input,
+                                                   CAuthenticationAccessTokenGenerateForAppResponse_Closure closure,
+                                                   void *closure_data);
+void authentication__enumerate_tokens(ProtobufCService *service,
+                                      const CAuthenticationRefreshTokenEnumerateRequest *input,
+                                      CAuthenticationRefreshTokenEnumerateResponse_Closure closure,
+                                      void *closure_data);
+void authentication__get_auth_sessions_for_account(ProtobufCService *service,
+                                                   const CAuthenticationGetAuthSessionsForAccountRequest *input,
+                                                   CAuthenticationGetAuthSessionsForAccountResponse_Closure closure,
+                                                   void *closure_data);
+void authentication__migrate_mobile_session(ProtobufCService *service,
+                                            const CAuthenticationMigrateMobileSessionRequest *input,
+                                            CAuthenticationMigrateMobileSessionResponse_Closure closure,
+                                            void *closure_data);
+void authentication__revoke_refresh_token(ProtobufCService *service,
+                                          const CAuthenticationRefreshTokenRevokeRequest *input,
+                                          CAuthenticationRefreshTokenRevokeResponse_Closure closure,
+                                          void *closure_data);
+typedef struct AuthenticationSupport_Service AuthenticationSupport_Service;
+struct AuthenticationSupport_Service
+{
+  ProtobufCService base;
+  void (*query_refresh_tokens_by_account)(AuthenticationSupport_Service *service,
+                                          const CAuthenticationSupportQueryRefreshTokensByAccountRequest *input,
+                                          CAuthenticationSupportQueryRefreshTokensByAccountResponse_Closure closure,
+                                          void *closure_data);
+  void (*query_refresh_token_by_id)(AuthenticationSupport_Service *service,
+                                    const CAuthenticationSupportQueryRefreshTokenByIDRequest *input,
+                                    CAuthenticationSupportQueryRefreshTokenByIDResponse_Closure closure,
+                                    void *closure_data);
+  void (*revoke_token)(AuthenticationSupport_Service *service,
+                       const CAuthenticationSupportRevokeTokenRequest *input,
+                       CAuthenticationSupportRevokeTokenResponse_Closure closure,
+                       void *closure_data);
+  void (*get_token_history)(AuthenticationSupport_Service *service,
+                            const CAuthenticationSupportGetTokenHistoryRequest *input,
+                            CAuthenticationSupportGetTokenHistoryResponse_Closure closure,
+                            void *closure_data);
+};
+typedef void (*AuthenticationSupport_ServiceDestroy)(AuthenticationSupport_Service *);
+void authentication_support__init (AuthenticationSupport_Service *service,
+                                   AuthenticationSupport_ServiceDestroy destroy);
+#define AUTHENTICATION_SUPPORT__BASE_INIT \
+    { &authentication_support__descriptor, protobuf_c_service_invoke_internal, NULL }
+#define AUTHENTICATION_SUPPORT__INIT(function_prefix__) \
+    { AUTHENTICATION_SUPPORT__BASE_INIT,\
+      function_prefix__ ## query_refresh_tokens_by_account,\
+      function_prefix__ ## query_refresh_token_by_id,\
+      function_prefix__ ## revoke_token,\
+      function_prefix__ ## get_token_history  }
+void authentication_support__query_refresh_tokens_by_account(ProtobufCService *service,
+                                                             const CAuthenticationSupportQueryRefreshTokensByAccountRequest *input,
+                                                             CAuthenticationSupportQueryRefreshTokensByAccountResponse_Closure closure,
+                                                             void *closure_data);
+void authentication_support__query_refresh_token_by_id(ProtobufCService *service,
+                                                       const CAuthenticationSupportQueryRefreshTokenByIDRequest *input,
+                                                       CAuthenticationSupportQueryRefreshTokenByIDResponse_Closure closure,
+                                                       void *closure_data);
+void authentication_support__revoke_token(ProtobufCService *service,
+                                          const CAuthenticationSupportRevokeTokenRequest *input,
+                                          CAuthenticationSupportRevokeTokenResponse_Closure closure,
+                                          void *closure_data);
+void authentication_support__get_token_history(ProtobufCService *service,
+                                               const CAuthenticationSupportGetTokenHistoryRequest *input,
+                                               CAuthenticationSupportGetTokenHistoryResponse_Closure closure,
+                                               void *closure_data);
+typedef struct CloudGaming_Service CloudGaming_Service;
+struct CloudGaming_Service
+{
+  ProtobufCService base;
+  void (*create_nonce)(CloudGaming_Service *service,
+                       const CCloudGamingCreateNonceRequest *input,
+                       CCloudGamingCreateNonceResponse_Closure closure,
+                       void *closure_data);
+  void (*get_time_remaining)(CloudGaming_Service *service,
+                             const CCloudGamingGetTimeRemainingRequest *input,
+                             CCloudGamingGetTimeRemainingResponse_Closure closure,
+                             void *closure_data);
+};
+typedef void (*CloudGaming_ServiceDestroy)(CloudGaming_Service *);
+void cloud_gaming__init (CloudGaming_Service *service,
+                         CloudGaming_ServiceDestroy destroy);
+#define CLOUD_GAMING__BASE_INIT \
+    { &cloud_gaming__descriptor, protobuf_c_service_invoke_internal, NULL }
+#define CLOUD_GAMING__INIT(function_prefix__) \
+    { CLOUD_GAMING__BASE_INIT,\
+      function_prefix__ ## create_nonce,\
+      function_prefix__ ## get_time_remaining  }
+void cloud_gaming__create_nonce(ProtobufCService *service,
+                                const CCloudGamingCreateNonceRequest *input,
+                                CCloudGamingCreateNonceResponse_Closure closure,
+                                void *closure_data);
+void cloud_gaming__get_time_remaining(ProtobufCService *service,
+                                      const CCloudGamingGetTimeRemainingRequest *input,
+                                      CCloudGamingGetTimeRemainingResponse_Closure closure,
+                                      void *closure_data);
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_steammessages_5fauth_2esteamclient_2eproto__INCLUDED */
diff --git a/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.proto b/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.proto
new file mode 100644
index 0000000000..f39bf9125a
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_auth.steamclient.proto
@@ -0,0 +1,411 @@
+import "steammessages_base.proto";
+import "steammessages_unified_base.steamclient.proto";
+import "enums.proto";
+
+option cc_generic_services = true;
+
+enum EAuthTokenPlatformType {
+	k_EAuthTokenPlatformType_Unknown = 0;
+	k_EAuthTokenPlatformType_SteamClient = 1;
+	k_EAuthTokenPlatformType_WebBrowser = 2;
+	k_EAuthTokenPlatformType_MobileApp = 3;
+}
+
+enum EAuthSessionGuardType {
+	k_EAuthSessionGuardType_Unknown = 0;
+	k_EAuthSessionGuardType_None = 1;
+	k_EAuthSessionGuardType_EmailCode = 2;
+	k_EAuthSessionGuardType_DeviceCode = 3;
+	k_EAuthSessionGuardType_DeviceConfirmation = 4;
+	k_EAuthSessionGuardType_EmailConfirmation = 5;
+	k_EAuthSessionGuardType_MachineToken = 6;
+	k_EAuthSessionGuardType_LegacyMachineAuth = 7;
+}
+
+enum EAuthSessionSecurityHistory {
+	k_EAuthSessionSecurityHistory_Invalid = 0;
+	k_EAuthSessionSecurityHistory_UsedPreviously = 1;
+	k_EAuthSessionSecurityHistory_NoPriorHistory = 2;
+}
+
+enum EAuthTokenRevokeAction {
+	k_EAuthTokenRevokeLogout = 0;
+	k_EAuthTokenRevokePermanent = 1;
+	k_EAuthTokenRevokeReplaced = 2;
+	k_EAuthTokenRevokeSupport = 3;
+	k_EAuthTokenRevokeConsume = 4;
+}
+
+enum EAuthTokenState {
+	k_EAuthTokenState_Invalid = 0;
+	k_EAuthTokenState_New = 1;
+	k_EAuthTokenState_Confirmed = 2;
+	k_EAuthTokenState_Issued = 3;
+	k_EAuthTokenState_Denied = 4;
+	k_EAuthTokenState_LoggedOut = 5;
+	k_EAuthTokenState_Consumed = 6;
+	k_EAuthTokenState_Revoked = 99;
+}
+
+message CAuthentication_GetPasswordRSAPublicKey_Request {
+	optional string account_name = 1 [(description) = "user-provided account name to get an RSA key for"];
+}
+
+message CAuthentication_GetPasswordRSAPublicKey_Response {
+	optional string publickey_mod = 1 [(description) = "the public key modulus"];
+	optional string publickey_exp = 2 [(description) = "the public key exponent"];
+	optional uint64 timestamp = 3 [(description) = "the timestamp the key was generated"];
+}
+
+message CAuthentication_DeviceDetails {
+	optional string device_friendly_name = 1 [(description) = "User-supplied, or client-supplied, friendly name of device"];
+	optional .EAuthTokenPlatformType platform_type = 2 [default = k_EAuthTokenPlatformType_Unknown, (description) = "EAuthTokenPlatformType, claimed, of device"];
+	optional int32 os_type = 3 [(description) = "EOSType, claimed, of authorized device"];
+	optional uint32 gaming_device_type = 4 [(description) = "EGamingDeviceType, claimed, of authorized device for steam client-type devices"];
+}
+
+message CAuthentication_BeginAuthSessionViaQR_Request {
+	optional string device_friendly_name = 1;
+	optional .EAuthTokenPlatformType platform_type = 2 [default = k_EAuthTokenPlatformType_Unknown];
+	optional .CAuthentication_DeviceDetails device_details = 3 [(description) = "User-supplied details about the device attempting to sign in"];
+	optional string website_id = 4 [default = "Unknown", (description) = "(EMachineAuthWebDomain) identifier of client requesting auth"];
+}
+
+message CAuthentication_AllowedConfirmation {
+	optional .EAuthSessionGuardType confirmation_type = 1 [default = k_EAuthSessionGuardType_Unknown, (description) = "authentication can proceed with this confirmation type"];
+	optional string associated_message = 2 [(description) = "message to be interpreted depending on the confirmation type. for email confirmation, this might be the redacted email address to which email was sent."];
+}
+
+message CAuthentication_BeginAuthSessionViaQR_Response {
+	optional uint64 client_id = 1 [(description) = "unique identifier of requestor, also used for routing, portion of QR code"];
+	optional string challenge_url = 2 [(description) = "URL based on client ID, which will be rendered as QR code"];
+	optional bytes request_id = 3 [(description) = "unique request ID to be presented by requestor at poll time - must not be rendered in QR"];
+	optional float interval = 4 [(description) = "refresh interval with which requestor should call PollAuthSessionStatus"];
+	repeated .CAuthentication_AllowedConfirmation allowed_confirmations = 5 [(description) = "the confirmation types that will be able to confirm the request"];
+	optional int32 version = 6 [(description) = "version of the QR data"];
+}
+
+message CAuthentication_BeginAuthSessionViaCredentials_Request {
+	optional string device_friendly_name = 1;
+	optional string account_name = 2;
+	optional string encrypted_password = 3 [(description) = "password, RSA encrypted client side"];
+	optional uint64 encryption_timestamp = 4 [(description) = "timestamp to map to a key - STime"];
+	optional bool remember_login = 5 [(description) = "deprecated"];
+	optional .EAuthTokenPlatformType platform_type = 6 [default = k_EAuthTokenPlatformType_Unknown];
+	optional .ESessionPersistence persistence = 7 [default = k_ESessionPersistence_Persistent, (description) = "whether we are requesting a persistent or an ephemeral session"];
+	optional string website_id = 8 [default = "Unknown", (description) = "(EMachineAuthWebDomain) identifier of client requesting auth"];
+	optional .CAuthentication_DeviceDetails device_details = 9 [(description) = "User-supplied details about the device attempting to sign in"];
+	optional string guard_data = 10 [(description) = "steam guard data for client login"];
+	optional uint32 language = 11;
+	optional int32 qos_level = 12 [default = 2, (description) = "[ENetQOSLevel] client-specified priority for this auth attempt"];
+}
+
+message CAuthentication_BeginAuthSessionViaCredentials_Response {
+	optional uint64 client_id = 1 [(description) = "unique identifier of requestor, also used for routing"];
+	optional bytes request_id = 2 [(description) = "unique request ID to be presented by requestor at poll time - must not be transferred or displayed"];
+	optional float interval = 3 [(description) = "refresh interval with which requestor should call PollAuthSessionStatus"];
+	repeated .CAuthentication_AllowedConfirmation allowed_confirmations = 4 [(description) = "the confirmation types that will be able to confirm the request"];
+	optional uint64 steamid = 5 [(description) = "steamid of the account logging in - will only be included if the credentials were correct"];
+	optional string weak_token = 6 [(description) = "partial-authentication token - limited lifetime and scope, included only if credentials were valid"];
+	optional string agreement_session_url = 7 [(description) = "agreement the user needs to agree to"];
+	optional string extended_error_message = 8 [(description) = "error string to display if supported by the client"];
+}
+
+message CAuthentication_PollAuthSessionStatus_Request {
+	optional uint64 client_id = 1;
+	optional bytes request_id = 2;
+	optional fixed64 token_to_revoke = 3 [(description) = "If this is set to a token owned by this user, that token will be retired"];
+}
+
+message CAuthentication_PollAuthSessionStatus_Response {
+	optional uint64 new_client_id = 1 [(description) = "if challenge is old, this is the new client id"];
+	optional string new_challenge_url = 2 [(description) = "if challenge is old, this is the new challenge ID to re-render for mobile confirmation"];
+	optional string refresh_token = 3 [(description) = "if login has been confirmed, this is the requestor's new refresh token"];
+	optional string access_token = 4 [(description) = "if login has been confirmed, this is a new token subordinate to refresh_token"];
+	optional bool had_remote_interaction = 5 [(description) = "whether or not the auth session appears to have had remote interaction from a potential confirmer"];
+	optional string account_name = 6 [(description) = "account name of authenticating account, for use by UI layer"];
+	optional string new_guard_data = 7 [(description) = "if login has been confirmed, may contain remembered machine ID for future login"];
+	optional string agreement_session_url = 8 [(description) = "agreement the user needs to agree to"];
+}
+
+message CAuthentication_GetAuthSessionInfo_Request {
+	optional uint64 client_id = 1 [(description) = "client ID from scanned QR Code, used for routing"];
+}
+
+message CAuthentication_GetAuthSessionInfo_Response {
+	optional string ip = 1 [(description) = "IP address of requestor"];
+	optional string geoloc = 2 [(description) = "geoloc info of requestor"];
+	optional string city = 3 [(description) = "city of requestor"];
+	optional string state = 4 [(description) = "state of requestor"];
+	optional string country = 5 [(description) = "country of requestor"];
+	optional .EAuthTokenPlatformType platform_type = 6 [default = k_EAuthTokenPlatformType_Unknown, (description) = "platform type of requestor"];
+	optional string device_friendly_name = 7 [(description) = "name of requestor device"];
+	optional int32 version = 8 [(description) = "version field"];
+	optional .EAuthSessionSecurityHistory login_history = 9 [default = k_EAuthSessionSecurityHistory_Invalid, (description) = "whether the ip has previuously been used on the account successfully"];
+	optional bool requestor_location_mismatch = 10 [(description) = "whether the requestor location matches this requests location"];
+	optional bool high_usage_login = 11 [(description) = "whether this login has seen high usage recently"];
+	optional .ESessionPersistence requested_persistence = 12 [default = k_ESessionPersistence_Invalid, (description) = "session persistence requestor has indicated they want"];
+}
+
+message CAuthentication_UpdateAuthSessionWithMobileConfirmation_Request {
+	optional int32 version = 1 [(description) = "version field"];
+	optional uint64 client_id = 2 [(description) = "pending client ID, from scanned QR Code"];
+	optional fixed64 steamid = 3 [(description) = "user who wants to login"];
+	optional bytes signature = 4 [(description) = "HMAC digest over {version,client_id,steamid} via user's private key"];
+	optional bool confirm = 5 [default = false, (description) = "Whether to confirm the login (true) or deny the login (false)"];
+	optional .ESessionPersistence persistence = 6 [default = k_ESessionPersistence_Persistent, (description) = "whether we are requesting a persistent or an ephemeral session"];
+}
+
+message CAuthentication_UpdateAuthSessionWithMobileConfirmation_Response {
+}
+
+message CAuthentication_UpdateAuthSessionWithSteamGuardCode_Request {
+	optional uint64 client_id = 1 [(description) = "pending client ID, from initialized session"];
+	optional fixed64 steamid = 2 [(description) = "user who wants to login"];
+	optional string code = 3 [(description) = "confirmation code"];
+	optional .EAuthSessionGuardType code_type = 4 [default = k_EAuthSessionGuardType_Unknown, (description) = "type of confirmation code"];
+}
+
+message CAuthentication_UpdateAuthSessionWithSteamGuardCode_Response {
+	optional string agreement_session_url = 7 [(description) = "agreement the user needs to agree to"];
+}
+
+message CAuthentication_AccessToken_GenerateForApp_Request {
+	optional string refresh_token = 1;
+	optional fixed64 steamid = 2;
+}
+
+message CAuthentication_AccessToken_GenerateForApp_Response {
+	optional string access_token = 1;
+}
+
+message CAuthentication_RefreshToken_Enumerate_Request {
+}
+
+message CAuthentication_RefreshToken_Enumerate_Response {
+	message TokenUsageEvent {
+		optional uint32 time = 1 [(description) = "Approximate time of history event (may be deliberately fuzzed or omitted)"];
+		optional .CMsgIPAddress ip = 2 [(description) = "IP at which event was observed"];
+		optional string locale = 3;
+		optional string country = 4 [(description) = "Location (country code) of event, as inferred from IP"];
+		optional string state = 5 [(description) = "Location (state code) of event, as inferred from IP"];
+		optional string city = 6 [(description) = "Location (city) of event, as inferred from IP"];
+	}
+
+	message RefreshTokenDescription {
+		optional fixed64 token_id = 1 [(description) = "Persistent token/device identifier"];
+		optional string token_description = 2 [(description) = "client-supplied friendly name for the device"];
+		optional uint32 time_updated = 3;
+		optional .EAuthTokenPlatformType platform_type = 4 [default = k_EAuthTokenPlatformType_Unknown, (description) = "gross platform type (mobile/client/browser)"];
+		optional bool logged_in = 5 [(description) = "If true, this token is currently valid. False indicates it is a machine token - ok for steamguard if you know the credential"];
+		optional uint32 os_platform = 6 [(description) = "EPlatformType - rough classification of device OS, if known"];
+		optional uint32 auth_type = 7 [(description) = "EAuthTokenGuardType - device authorization mechanism, if known"];
+		optional uint32 gaming_device_type = 8 [(description) = "EGamingDeviceType - classify console/PC/SteamDeck, if known; applies only for Steam Client devices"];
+		optional .CAuthentication_RefreshToken_Enumerate_Response.TokenUsageEvent first_seen = 9 [(description) = "Information about original authorization event"];
+		optional .CAuthentication_RefreshToken_Enumerate_Response.TokenUsageEvent last_seen = 10 [(description) = "Information about most-recently seen, if known for this device"];
+		optional int32 os_type = 11 [(description) = "EOSType - specific device OS, if known"];
+	}
+
+	repeated .CAuthentication_RefreshToken_Enumerate_Response.RefreshTokenDescription refresh_tokens = 1;
+	optional fixed64 requesting_token = 2;
+}
+
+message CAuthentication_GetAuthSessionsForAccount_Request {
+}
+
+message CAuthentication_GetAuthSessionsForAccount_Response {
+	repeated uint64 client_ids = 1 [(description) = "unique identifier of requestor, also used for routing"];
+}
+
+message CAuthentication_MigrateMobileSession_Request {
+	optional fixed64 steamid = 1 [(description) = "Steam ID of the user to migrate"];
+	optional string token = 2 [(description) = "WG Token to migrate"];
+	optional string signature = 3 [(description) = "Signature over the wg token using the user's 2FA token"];
+}
+
+message CAuthentication_MigrateMobileSession_Response {
+	optional string refresh_token = 1;
+	optional string access_token = 2;
+}
+
+message CAuthentication_RefreshToken_Revoke_Request {
+	optional fixed64 token_id = 1;
+	optional fixed64 steamid = 2 [(description) = "Token holder if an admin action on behalf of another user"];
+	optional .EAuthTokenRevokeAction revoke_action = 3 [default = k_EAuthTokenRevokePermanent, (description) = "Select between logout and logout-and-forget-machine"];
+	optional bytes signature = 4 [(description) = "required signature over token_id"];
+}
+
+message CAuthentication_RefreshToken_Revoke_Response {
+}
+
+message CAuthenticationSupport_QueryRefreshTokensByAccount_Request {
+	optional fixed64 steamid = 1 [(description) = "SteamID of the account to query (required)"];
+	optional bool include_revoked_tokens = 2 [(description) = "Includes tokens that are revoked or expired in the query"];
+}
+
+message CSupportRefreshTokenDescription {
+	message TokenUsageEvent {
+		optional uint32 time = 1 [(description) = "Approximate time of history event (may be deliberately fuzzed or omitted)"];
+		optional .CMsgIPAddress ip = 2 [(description) = "IP at which event was observed"];
+		optional string country = 3 [(description) = "Location (country code) of event, as inferred from IP"];
+		optional string state = 4 [(description) = "Location (state code) of event, as inferred from IP"];
+		optional string city = 5 [(description) = "Location (city) of event, as inferred from IP"];
+	}
+
+	optional fixed64 token_id = 1;
+	optional string token_description = 2;
+	optional uint32 time_updated = 3;
+	optional .EAuthTokenPlatformType platform_type = 4 [default = k_EAuthTokenPlatformType_Unknown];
+	optional .EAuthTokenState token_state = 5 [default = k_EAuthTokenState_Invalid];
+	optional fixed64 owner_steamid = 6;
+	optional uint32 os_platform = 7 [(description) = "EPlatformType - rough classification of device OS, if known"];
+	optional int32 os_type = 8 [(description) = "EOSType - specific device OS, if known"];
+	optional uint32 auth_type = 9 [(description) = "EAuthTokenGuardType - device authorization mechanism, if known"];
+	optional uint32 gaming_device_type = 10 [(description) = "EGamingDeviceType - classify console/PC/SteamDeck, if known; applies only for Steam Client devices"];
+	optional .CSupportRefreshTokenDescription.TokenUsageEvent first_seen = 11 [(description) = "Information about original authorization event"];
+	optional .CSupportRefreshTokenDescription.TokenUsageEvent last_seen = 12 [(description) = "Information about most-recently seen, if known for this device"];
+}
+
+message CAuthenticationSupport_QueryRefreshTokensByAccount_Response {
+	repeated .CSupportRefreshTokenDescription refresh_tokens = 1;
+	optional int32 last_token_reset = 2;
+}
+
+message CAuthenticationSupport_QueryRefreshTokenByID_Request {
+	optional fixed64 token_id = 1 [(description) = "Token ID of the token to look up (required)"];
+}
+
+message CAuthenticationSupport_QueryRefreshTokenByID_Response {
+	repeated .CSupportRefreshTokenDescription refresh_tokens = 1;
+}
+
+message CAuthenticationSupport_RevokeToken_Request {
+	optional fixed64 token_id = 1 [(description) = "Token ID of the token to revoke (required)"];
+	optional fixed64 steamid = 2 [(description) = "Steam ID of the owner of that token (required)"];
+}
+
+message CAuthenticationSupport_RevokeToken_Response {
+}
+
+message CAuthenticationSupport_GetTokenHistory_Request {
+	optional fixed64 token_id = 1 [(description) = "Token ID of the token to get history for (required)"];
+}
+
+message CSupportRefreshTokenAudit {
+	optional int32 action = 1;
+	optional uint32 time = 2;
+	optional .CMsgIPAddress ip = 3;
+	optional fixed64 actor = 4;
+}
+
+message CAuthenticationSupport_GetTokenHistory_Response {
+	repeated .CSupportRefreshTokenAudit history = 1;
+}
+
+message CCloudGaming_CreateNonce_Request {
+	optional string platform = 1;
+	optional uint32 appid = 2;
+}
+
+message CCloudGaming_CreateNonce_Response {
+	optional string nonce = 1;
+	optional uint32 expiry = 2;
+}
+
+message CCloudGaming_GetTimeRemaining_Request {
+	optional string platform = 1;
+	repeated uint32 appid_list = 2;
+}
+
+message CCloudGaming_TimeRemaining {
+	optional uint32 appid = 1;
+	optional uint32 minutes_remaining = 2;
+}
+
+message CCloudGaming_GetTimeRemaining_Response {
+	repeated .CCloudGaming_TimeRemaining entries = 2;
+}
+
+service Authentication {
+	option (service_description) = "Authentication Service";
+
+	rpc GetPasswordRSAPublicKey (.CAuthentication_GetPasswordRSAPublicKey_Request) returns (.CAuthentication_GetPasswordRSAPublicKey_Response) {
+		option (method_description) = "Fetches RSA public key to use to encrypt passwords for a given account name";
+	}
+
+	rpc BeginAuthSessionViaQR (.CAuthentication_BeginAuthSessionViaQR_Request) returns (.CAuthentication_BeginAuthSessionViaQR_Response) {
+		option (method_description) = "start authentication process";
+	}
+
+	rpc BeginAuthSessionViaCredentials (.CAuthentication_BeginAuthSessionViaCredentials_Request) returns (.CAuthentication_BeginAuthSessionViaCredentials_Response) {
+		option (method_description) = "start authentication process";
+	}
+
+	rpc PollAuthSessionStatus (.CAuthentication_PollAuthSessionStatus_Request) returns (.CAuthentication_PollAuthSessionStatus_Response) {
+		option (method_description) = "poll during authentication process";
+	}
+
+	rpc GetAuthSessionInfo (.CAuthentication_GetAuthSessionInfo_Request) returns (.CAuthentication_GetAuthSessionInfo_Response) {
+		option (method_description) = "get metadata of specific auth session, this will also implicitly bind the calling account";
+	}
+
+	rpc UpdateAuthSessionWithMobileConfirmation (.CAuthentication_UpdateAuthSessionWithMobileConfirmation_Request) returns (.CAuthentication_UpdateAuthSessionWithMobileConfirmation_Response) {
+		option (method_description) = "approve an authentication session via mobile 2fa";
+	}
+
+	rpc UpdateAuthSessionWithSteamGuardCode (.CAuthentication_UpdateAuthSessionWithSteamGuardCode_Request) returns (.CAuthentication_UpdateAuthSessionWithSteamGuardCode_Response) {
+		option (method_description) = "approve an authentication session via steam guard code";
+	}
+
+	rpc GenerateAccessTokenForApp (.CAuthentication_AccessToken_GenerateForApp_Request) returns (.CAuthentication_AccessToken_GenerateForApp_Response) {
+		option (method_description) = "Given a refresh token for a client app audience (e.g. desktop client / mobile client), generate an access token";
+	}
+
+	rpc EnumerateTokens (.CAuthentication_RefreshToken_Enumerate_Request) returns (.CAuthentication_RefreshToken_Enumerate_Response) {
+		option (method_description) = "Enumerate durable (refresh) tokens for the given subject account";
+	}
+
+	rpc GetAuthSessionsForAccount (.CAuthentication_GetAuthSessionsForAccount_Request) returns (.CAuthentication_GetAuthSessionsForAccount_Response) {
+		option (method_description) = "Gets all active auth sessions for an account for reference by the mobile app";
+	}
+
+	rpc MigrateMobileSession (.CAuthentication_MigrateMobileSession_Request) returns (.CAuthentication_MigrateMobileSession_Response) {
+		option (method_description) = "Migrates a WG token to an access and refresh token using a signature generated with the user's 2FA secret";
+	}
+
+	rpc RevokeRefreshToken (.CAuthentication_RefreshToken_Revoke_Request) returns (.CAuthentication_RefreshToken_Revoke_Response) {
+		option (method_description) = "Mark the given refresh token as revoked";
+	}
+}
+
+service AuthenticationSupport {
+	option (service_description) = "Authentication Support Service";
+
+	rpc QueryRefreshTokensByAccount (.CAuthenticationSupport_QueryRefreshTokensByAccount_Request) returns (.CAuthenticationSupport_QueryRefreshTokensByAccount_Response) {
+		option (method_description) = "Asks the server for a list of refresh tokens associated with an account";
+	}
+
+	rpc QueryRefreshTokenByID (.CAuthenticationSupport_QueryRefreshTokenByID_Request) returns (.CAuthenticationSupport_QueryRefreshTokenByID_Response) {
+		option (method_description) = "Asks the server for a list of refresh tokens associated with an account";
+	}
+
+	rpc RevokeToken (.CAuthenticationSupport_RevokeToken_Request) returns (.CAuthenticationSupport_RevokeToken_Response) {
+		option (method_description) = "Revokes a user's auth token";
+	}
+
+	rpc GetTokenHistory (.CAuthenticationSupport_GetTokenHistory_Request) returns (.CAuthenticationSupport_GetTokenHistory_Response) {
+		option (method_description) = "Gets the audit history for a user's auth token";
+	}
+}
+
+service CloudGaming {
+	option (service_description) = "Methods for Steam cloud gaming operations";
+
+	rpc CreateNonce (.CCloudGaming_CreateNonce_Request) returns (.CCloudGaming_CreateNonce_Response) {
+		option (method_description) = "Create a nonce for a cloud gaming service session";
+	}
+
+	rpc GetTimeRemaining (.CCloudGaming_GetTimeRemaining_Request) returns (.CCloudGaming_GetTimeRemaining_Response) {
+		option (method_description) = "Get the amount of streaming time remaining for a set of apps";
+	}
+}
diff --git a/protocols/Steam/src/protobuf-c/steammessages_base.pb-c.cpp b/protocols/Steam/src/protobuf-c/steammessages_base.pb-c.cpp
new file mode 100644
index 0000000000..848bdc70bf
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_base.pb-c.cpp
@@ -0,0 +1,3706 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_base.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "steammessages_base.pb-c.h"
+size_t cmsg_ipaddress__get_packed_size
+                     (const CMsgIPAddress *message)
+{
+  assert(message->descriptor == &cmsg_ipaddress__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_ipaddress__pack
+                     (const CMsgIPAddress *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_ipaddress__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_ipaddress__pack_to_buffer
+                     (const CMsgIPAddress *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_ipaddress__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgIPAddress *
+       cmsg_ipaddress__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgIPAddress *)
+     protobuf_c_message_unpack (&cmsg_ipaddress__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_ipaddress__free_unpacked
+                     (CMsgIPAddress *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_ipaddress__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_ipaddress_bucket__get_packed_size
+                     (const CMsgIPAddressBucket *message)
+{
+  assert(message->descriptor == &cmsg_ipaddress_bucket__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_ipaddress_bucket__pack
+                     (const CMsgIPAddressBucket *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_ipaddress_bucket__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_ipaddress_bucket__pack_to_buffer
+                     (const CMsgIPAddressBucket *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_ipaddress_bucket__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgIPAddressBucket *
+       cmsg_ipaddress_bucket__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgIPAddressBucket *)
+     protobuf_c_message_unpack (&cmsg_ipaddress_bucket__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_ipaddress_bucket__free_unpacked
+                     (CMsgIPAddressBucket *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_ipaddress_bucket__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_gcrouting_proto_buf_header__get_packed_size
+                     (const CMsgGCRoutingProtoBufHeader *message)
+{
+  assert(message->descriptor == &cmsg_gcrouting_proto_buf_header__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_gcrouting_proto_buf_header__pack
+                     (const CMsgGCRoutingProtoBufHeader *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_gcrouting_proto_buf_header__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_gcrouting_proto_buf_header__pack_to_buffer
+                     (const CMsgGCRoutingProtoBufHeader *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_gcrouting_proto_buf_header__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgGCRoutingProtoBufHeader *
+       cmsg_gcrouting_proto_buf_header__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgGCRoutingProtoBufHeader *)
+     protobuf_c_message_unpack (&cmsg_gcrouting_proto_buf_header__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_gcrouting_proto_buf_header__free_unpacked
+                     (CMsgGCRoutingProtoBufHeader *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_gcrouting_proto_buf_header__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_proto_buf_header__get_packed_size
+                     (const CMsgProtoBufHeader *message)
+{
+  assert(message->descriptor == &cmsg_proto_buf_header__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_proto_buf_header__pack
+                     (const CMsgProtoBufHeader *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_proto_buf_header__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_proto_buf_header__pack_to_buffer
+                     (const CMsgProtoBufHeader *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_proto_buf_header__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgProtoBufHeader *
+       cmsg_proto_buf_header__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgProtoBufHeader *)
+     protobuf_c_message_unpack (&cmsg_proto_buf_header__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_proto_buf_header__free_unpacked
+                     (CMsgProtoBufHeader *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_proto_buf_header__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_multi__get_packed_size
+                     (const CMsgMulti *message)
+{
+  assert(message->descriptor == &cmsg_multi__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_multi__pack
+                     (const CMsgMulti *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_multi__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_multi__pack_to_buffer
+                     (const CMsgMulti *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_multi__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgMulti *
+       cmsg_multi__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgMulti *)
+     protobuf_c_message_unpack (&cmsg_multi__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_multi__free_unpacked
+                     (CMsgMulti *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_multi__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_protobuf_wrapped__get_packed_size
+                     (const CMsgProtobufWrapped *message)
+{
+  assert(message->descriptor == &cmsg_protobuf_wrapped__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_protobuf_wrapped__pack
+                     (const CMsgProtobufWrapped *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_protobuf_wrapped__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_protobuf_wrapped__pack_to_buffer
+                     (const CMsgProtobufWrapped *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_protobuf_wrapped__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgProtobufWrapped *
+       cmsg_protobuf_wrapped__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgProtobufWrapped *)
+     protobuf_c_message_unpack (&cmsg_protobuf_wrapped__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_protobuf_wrapped__free_unpacked
+                     (CMsgProtobufWrapped *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_protobuf_wrapped__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_auth_ticket__get_packed_size
+                     (const CMsgAuthTicket *message)
+{
+  assert(message->descriptor == &cmsg_auth_ticket__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_auth_ticket__pack
+                     (const CMsgAuthTicket *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_auth_ticket__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_auth_ticket__pack_to_buffer
+                     (const CMsgAuthTicket *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_auth_ticket__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgAuthTicket *
+       cmsg_auth_ticket__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgAuthTicket *)
+     protobuf_c_message_unpack (&cmsg_auth_ticket__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_auth_ticket__free_unpacked
+                     (CMsgAuthTicket *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_auth_ticket__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccddbapp_detail_common__get_packed_size
+                     (const CCDDBAppDetailCommon *message)
+{
+  assert(message->descriptor == &ccddbapp_detail_common__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccddbapp_detail_common__pack
+                     (const CCDDBAppDetailCommon *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccddbapp_detail_common__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccddbapp_detail_common__pack_to_buffer
+                     (const CCDDBAppDetailCommon *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccddbapp_detail_common__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCDDBAppDetailCommon *
+       ccddbapp_detail_common__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCDDBAppDetailCommon *)
+     protobuf_c_message_unpack (&ccddbapp_detail_common__descriptor,
+                                allocator, len, data);
+}
+void   ccddbapp_detail_common__free_unpacked
+                     (CCDDBAppDetailCommon *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccddbapp_detail_common__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_app_rights__get_packed_size
+                     (const CMsgAppRights *message)
+{
+  assert(message->descriptor == &cmsg_app_rights__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_app_rights__pack
+                     (const CMsgAppRights *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_app_rights__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_app_rights__pack_to_buffer
+                     (const CMsgAppRights *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_app_rights__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgAppRights *
+       cmsg_app_rights__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgAppRights *)
+     protobuf_c_message_unpack (&cmsg_app_rights__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_app_rights__free_unpacked
+                     (CMsgAppRights *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_app_rights__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccurator_preferences__get_packed_size
+                     (const CCuratorPreferences *message)
+{
+  assert(message->descriptor == &ccurator_preferences__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccurator_preferences__pack
+                     (const CCuratorPreferences *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccurator_preferences__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccurator_preferences__pack_to_buffer
+                     (const CCuratorPreferences *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccurator_preferences__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCuratorPreferences *
+       ccurator_preferences__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCuratorPreferences *)
+     protobuf_c_message_unpack (&ccurator_preferences__descriptor,
+                                allocator, len, data);
+}
+void   ccurator_preferences__free_unpacked
+                     (CCuratorPreferences *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccurator_preferences__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t clocalization_token__get_packed_size
+                     (const CLocalizationToken *message)
+{
+  assert(message->descriptor == &clocalization_token__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t clocalization_token__pack
+                     (const CLocalizationToken *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &clocalization_token__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t clocalization_token__pack_to_buffer
+                     (const CLocalizationToken *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &clocalization_token__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CLocalizationToken *
+       clocalization_token__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CLocalizationToken *)
+     protobuf_c_message_unpack (&clocalization_token__descriptor,
+                                allocator, len, data);
+}
+void   clocalization_token__free_unpacked
+                     (CLocalizationToken *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &clocalization_token__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cclan_event_user_news_tuple__get_packed_size
+                     (const CClanEventUserNewsTuple *message)
+{
+  assert(message->descriptor == &cclan_event_user_news_tuple__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cclan_event_user_news_tuple__pack
+                     (const CClanEventUserNewsTuple *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cclan_event_user_news_tuple__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cclan_event_user_news_tuple__pack_to_buffer
+                     (const CClanEventUserNewsTuple *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cclan_event_user_news_tuple__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CClanEventUserNewsTuple *
+       cclan_event_user_news_tuple__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CClanEventUserNewsTuple *)
+     protobuf_c_message_unpack (&cclan_event_user_news_tuple__descriptor,
+                                allocator, len, data);
+}
+void   cclan_event_user_news_tuple__free_unpacked
+                     (CClanEventUserNewsTuple *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cclan_event_user_news_tuple__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cclan_match_event_by_range__get_packed_size
+                     (const CClanMatchEventByRange *message)
+{
+  assert(message->descriptor == &cclan_match_event_by_range__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cclan_match_event_by_range__pack
+                     (const CClanMatchEventByRange *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cclan_match_event_by_range__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cclan_match_event_by_range__pack_to_buffer
+                     (const CClanMatchEventByRange *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cclan_match_event_by_range__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CClanMatchEventByRange *
+       cclan_match_event_by_range__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CClanMatchEventByRange *)
+     protobuf_c_message_unpack (&cclan_match_event_by_range__descriptor,
+                                allocator, len, data);
+}
+void   cclan_match_event_by_range__free_unpacked
+                     (CClanMatchEventByRange *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cclan_match_event_by_range__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t ccommunity__clan_announcement_info__get_packed_size
+                     (const CCommunityClanAnnouncementInfo *message)
+{
+  assert(message->descriptor == &ccommunity__clan_announcement_info__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ccommunity__clan_announcement_info__pack
+                     (const CCommunityClanAnnouncementInfo *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &ccommunity__clan_announcement_info__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ccommunity__clan_announcement_info__pack_to_buffer
+                     (const CCommunityClanAnnouncementInfo *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &ccommunity__clan_announcement_info__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CCommunityClanAnnouncementInfo *
+       ccommunity__clan_announcement_info__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CCommunityClanAnnouncementInfo *)
+     protobuf_c_message_unpack (&ccommunity__clan_announcement_info__descriptor,
+                                allocator, len, data);
+}
+void   ccommunity__clan_announcement_info__free_unpacked
+                     (CCommunityClanAnnouncementInfo *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &ccommunity__clan_announcement_info__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cclan_event_data__get_packed_size
+                     (const CClanEventData *message)
+{
+  assert(message->descriptor == &cclan_event_data__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cclan_event_data__pack
+                     (const CClanEventData *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cclan_event_data__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cclan_event_data__pack_to_buffer
+                     (const CClanEventData *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cclan_event_data__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CClanEventData *
+       cclan_event_data__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CClanEventData *)
+     protobuf_c_message_unpack (&cclan_event_data__descriptor,
+                                allocator, len, data);
+}
+void   cclan_event_data__free_unpacked
+                     (CClanEventData *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cclan_event_data__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cbilling__address__get_packed_size
+                     (const CBillingAddress *message)
+{
+  assert(message->descriptor == &cbilling__address__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cbilling__address__pack
+                     (const CBillingAddress *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cbilling__address__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cbilling__address__pack_to_buffer
+                     (const CBillingAddress *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cbilling__address__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CBillingAddress *
+       cbilling__address__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CBillingAddress *)
+     protobuf_c_message_unpack (&cbilling__address__descriptor,
+                                allocator, len, data);
+}
+void   cbilling__address__free_unpacked
+                     (CBillingAddress *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cbilling__address__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cpackage_reservation_status__get_packed_size
+                     (const CPackageReservationStatus *message)
+{
+  assert(message->descriptor == &cpackage_reservation_status__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cpackage_reservation_status__pack
+                     (const CPackageReservationStatus *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cpackage_reservation_status__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cpackage_reservation_status__pack_to_buffer
+                     (const CPackageReservationStatus *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cpackage_reservation_status__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CPackageReservationStatus *
+       cpackage_reservation_status__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CPackageReservationStatus *)
+     protobuf_c_message_unpack (&cpackage_reservation_status__descriptor,
+                                allocator, len, data);
+}
+void   cpackage_reservation_status__free_unpacked
+                     (CPackageReservationStatus *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cpackage_reservation_status__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_key_value_pair__get_packed_size
+                     (const CMsgKeyValuePair *message)
+{
+  assert(message->descriptor == &cmsg_key_value_pair__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_key_value_pair__pack
+                     (const CMsgKeyValuePair *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_key_value_pair__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_key_value_pair__pack_to_buffer
+                     (const CMsgKeyValuePair *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_key_value_pair__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgKeyValuePair *
+       cmsg_key_value_pair__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgKeyValuePair *)
+     protobuf_c_message_unpack (&cmsg_key_value_pair__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_key_value_pair__free_unpacked
+                     (CMsgKeyValuePair *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_key_value_pair__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_key_value_set__get_packed_size
+                     (const CMsgKeyValueSet *message)
+{
+  assert(message->descriptor == &cmsg_key_value_set__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_key_value_set__pack
+                     (const CMsgKeyValueSet *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_key_value_set__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_key_value_set__pack_to_buffer
+                     (const CMsgKeyValueSet *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_key_value_set__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgKeyValueSet *
+       cmsg_key_value_set__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgKeyValueSet *)
+     protobuf_c_message_unpack (&cmsg_key_value_set__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_key_value_set__free_unpacked
+                     (CMsgKeyValueSet *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_key_value_set__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+static const ProtobufCFieldDescriptor cmsg_ipaddress__field_descriptors[2] =
+{
+  {
+    "v4",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED32,
+    offsetof(CMsgIPAddress, ip_case),
+    offsetof(CMsgIPAddress, v4),
+    NULL,
+    NULL,
+    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "v6",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgIPAddress, ip_case),
+    offsetof(CMsgIPAddress, v6),
+    NULL,
+    NULL,
+    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_ipaddress__field_indices_by_name[] = {
+  0,   /* field[0] = v4 */
+  1,   /* field[1] = v6 */
+};
+static const ProtobufCIntRange cmsg_ipaddress__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cmsg_ipaddress__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgIPAddress",
+  "CMsgIPAddress",
+  "CMsgIPAddress",
+  "",
+  sizeof(CMsgIPAddress),
+  2,
+  cmsg_ipaddress__field_descriptors,
+  cmsg_ipaddress__field_indices_by_name,
+  1,  cmsg_ipaddress__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_ipaddress_bucket__field_descriptors[2] =
+{
+  {
+    "original_ip_address",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CMsgIPAddressBucket, original_ip_address),
+    &cmsg_ipaddress__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "bucket",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgIPAddressBucket, has_bucket),
+    offsetof(CMsgIPAddressBucket, bucket),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_ipaddress_bucket__field_indices_by_name[] = {
+  1,   /* field[1] = bucket */
+  0,   /* field[0] = original_ip_address */
+};
+static const ProtobufCIntRange cmsg_ipaddress_bucket__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cmsg_ipaddress_bucket__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgIPAddressBucket",
+  "CMsgIPAddressBucket",
+  "CMsgIPAddressBucket",
+  "",
+  sizeof(CMsgIPAddressBucket),
+  2,
+  cmsg_ipaddress_bucket__field_descriptors,
+  cmsg_ipaddress_bucket__field_indices_by_name,
+  1,  cmsg_ipaddress_bucket__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_gcrouting_proto_buf_header__field_descriptors[2] =
+{
+  {
+    "dst_gcid_queue",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgGCRoutingProtoBufHeader, has_dst_gcid_queue),
+    offsetof(CMsgGCRoutingProtoBufHeader, dst_gcid_queue),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "dst_gc_dir_index",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgGCRoutingProtoBufHeader, has_dst_gc_dir_index),
+    offsetof(CMsgGCRoutingProtoBufHeader, dst_gc_dir_index),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_gcrouting_proto_buf_header__field_indices_by_name[] = {
+  1,   /* field[1] = dst_gc_dir_index */
+  0,   /* field[0] = dst_gcid_queue */
+};
+static const ProtobufCIntRange cmsg_gcrouting_proto_buf_header__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cmsg_gcrouting_proto_buf_header__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgGCRoutingProtoBufHeader",
+  "CMsgGCRoutingProtoBufHeader",
+  "CMsgGCRoutingProtoBufHeader",
+  "",
+  sizeof(CMsgGCRoutingProtoBufHeader),
+  2,
+  cmsg_gcrouting_proto_buf_header__field_descriptors,
+  cmsg_gcrouting_proto_buf_header__field_indices_by_name,
+  1,  cmsg_gcrouting_proto_buf_header__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const uint64_t cmsg_proto_buf_header__jobid_source__default_value = 18446744073709551615ull;
+static const uint64_t cmsg_proto_buf_header__jobid_target__default_value = 18446744073709551615ull;
+static const int32_t cmsg_proto_buf_header__eresult__default_value = 2;
+static const int32_t cmsg_proto_buf_header__transport_error__default_value = 1;
+static const uint64_t cmsg_proto_buf_header__messageid__default_value = 18446744073709551615ull;
+static const uint32_t cmsg_proto_buf_header__launcher_type__default_value = 0u;
+static const uint32_t cmsg_proto_buf_header__realm__default_value = 0u;
+static const int32_t cmsg_proto_buf_header__timeout_ms__default_value = -1;
+static const ProtobufCFieldDescriptor cmsg_proto_buf_header__field_descriptors[30] =
+{
+  {
+    "steamid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgProtoBufHeader, has_steamid),
+    offsetof(CMsgProtoBufHeader, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_sessionid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgProtoBufHeader, has_client_sessionid),
+    offsetof(CMsgProtoBufHeader, client_sessionid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "routing_appid",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_routing_appid),
+    offsetof(CMsgProtoBufHeader, routing_appid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "jobid_source",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgProtoBufHeader, has_jobid_source),
+    offsetof(CMsgProtoBufHeader, jobid_source),
+    NULL,
+    &cmsg_proto_buf_header__jobid_source__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "jobid_target",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgProtoBufHeader, has_jobid_target),
+    offsetof(CMsgProtoBufHeader, jobid_target),
+    NULL,
+    &cmsg_proto_buf_header__jobid_target__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "target_job_name",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgProtoBufHeader, target_job_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "eresult",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgProtoBufHeader, has_eresult),
+    offsetof(CMsgProtoBufHeader, eresult),
+    NULL,
+    &cmsg_proto_buf_header__eresult__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "error_message",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgProtoBufHeader, error_message),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ip",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, ip_addr_case),
+    offsetof(CMsgProtoBufHeader, ip),
+    NULL,
+    NULL,
+    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "auth_account_flags",
+    16,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_auth_account_flags),
+    offsetof(CMsgProtoBufHeader, auth_account_flags),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "transport_error",
+    17,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgProtoBufHeader, has_transport_error),
+    offsetof(CMsgProtoBufHeader, transport_error),
+    NULL,
+    &cmsg_proto_buf_header__transport_error__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "messageid",
+    18,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgProtoBufHeader, has_messageid),
+    offsetof(CMsgProtoBufHeader, messageid),
+    NULL,
+    &cmsg_proto_buf_header__messageid__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "publisher_group_id",
+    19,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_publisher_group_id),
+    offsetof(CMsgProtoBufHeader, publisher_group_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "sysid",
+    20,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_sysid),
+    offsetof(CMsgProtoBufHeader, sysid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "trace_tag",
+    21,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgProtoBufHeader, has_trace_tag),
+    offsetof(CMsgProtoBufHeader, trace_tag),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_source",
+    22,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_token_source),
+    offsetof(CMsgProtoBufHeader, token_source),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "admin_spoofing_user",
+    23,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgProtoBufHeader, has_admin_spoofing_user),
+    offsetof(CMsgProtoBufHeader, admin_spoofing_user),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "seq_num",
+    24,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgProtoBufHeader, has_seq_num),
+    offsetof(CMsgProtoBufHeader, seq_num),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "webapi_key_id",
+    25,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_webapi_key_id),
+    offsetof(CMsgProtoBufHeader, webapi_key_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_from_external_source",
+    26,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgProtoBufHeader, has_is_from_external_source),
+    offsetof(CMsgProtoBufHeader, is_from_external_source),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "forward_to_sysid",
+    27,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, n_forward_to_sysid),
+    offsetof(CMsgProtoBufHeader, forward_to_sysid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "cm_sysid",
+    28,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_cm_sysid),
+    offsetof(CMsgProtoBufHeader, cm_sysid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ip_v6",
+    29,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgProtoBufHeader, ip_addr_case),
+    offsetof(CMsgProtoBufHeader, ip_v6),
+    NULL,
+    NULL,
+    0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "launcher_type",
+    31,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_launcher_type),
+    offsetof(CMsgProtoBufHeader, launcher_type),
+    NULL,
+    &cmsg_proto_buf_header__launcher_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "realm",
+    32,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_realm),
+    offsetof(CMsgProtoBufHeader, realm),
+    NULL,
+    &cmsg_proto_buf_header__realm__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "timeout_ms",
+    33,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgProtoBufHeader, has_timeout_ms),
+    offsetof(CMsgProtoBufHeader, timeout_ms),
+    NULL,
+    &cmsg_proto_buf_header__timeout_ms__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "debug_source",
+    34,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgProtoBufHeader, debug_source),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "debug_source_string_index",
+    35,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgProtoBufHeader, has_debug_source_string_index),
+    offsetof(CMsgProtoBufHeader, debug_source_string_index),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_id",
+    36,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgProtoBufHeader, has_token_id),
+    offsetof(CMsgProtoBufHeader, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "routing_gc",
+    37,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CMsgProtoBufHeader, routing_gc),
+    &cmsg_gcrouting_proto_buf_header__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_proto_buf_header__field_indices_by_name[] = {
+  16,   /* field[16] = admin_spoofing_user */
+  9,   /* field[9] = auth_account_flags */
+  1,   /* field[1] = client_sessionid */
+  21,   /* field[21] = cm_sysid */
+  26,   /* field[26] = debug_source */
+  27,   /* field[27] = debug_source_string_index */
+  6,   /* field[6] = eresult */
+  7,   /* field[7] = error_message */
+  20,   /* field[20] = forward_to_sysid */
+  8,   /* field[8] = ip */
+  22,   /* field[22] = ip_v6 */
+  19,   /* field[19] = is_from_external_source */
+  3,   /* field[3] = jobid_source */
+  4,   /* field[4] = jobid_target */
+  23,   /* field[23] = launcher_type */
+  11,   /* field[11] = messageid */
+  12,   /* field[12] = publisher_group_id */
+  24,   /* field[24] = realm */
+  2,   /* field[2] = routing_appid */
+  29,   /* field[29] = routing_gc */
+  17,   /* field[17] = seq_num */
+  0,   /* field[0] = steamid */
+  13,   /* field[13] = sysid */
+  5,   /* field[5] = target_job_name */
+  25,   /* field[25] = timeout_ms */
+  28,   /* field[28] = token_id */
+  15,   /* field[15] = token_source */
+  14,   /* field[14] = trace_tag */
+  10,   /* field[10] = transport_error */
+  18,   /* field[18] = webapi_key_id */
+};
+static const ProtobufCIntRange cmsg_proto_buf_header__number_ranges[3 + 1] =
+{
+  { 1, 0 },
+  { 10, 3 },
+  { 31, 23 },
+  { 0, 30 }
+};
+const ProtobufCMessageDescriptor cmsg_proto_buf_header__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgProtoBufHeader",
+  "CMsgProtoBufHeader",
+  "CMsgProtoBufHeader",
+  "",
+  sizeof(CMsgProtoBufHeader),
+  30,
+  cmsg_proto_buf_header__field_descriptors,
+  cmsg_proto_buf_header__field_indices_by_name,
+  3,  cmsg_proto_buf_header__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_multi__field_descriptors[2] =
+{
+  {
+    "size_unzipped",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgMulti, has_size_unzipped),
+    offsetof(CMsgMulti, size_unzipped),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "message_body",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgMulti, has_message_body),
+    offsetof(CMsgMulti, message_body),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_multi__field_indices_by_name[] = {
+  1,   /* field[1] = message_body */
+  0,   /* field[0] = size_unzipped */
+};
+static const ProtobufCIntRange cmsg_multi__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cmsg_multi__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgMulti",
+  "CMsgMulti",
+  "CMsgMulti",
+  "",
+  sizeof(CMsgMulti),
+  2,
+  cmsg_multi__field_descriptors,
+  cmsg_multi__field_indices_by_name,
+  1,  cmsg_multi__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_protobuf_wrapped__field_descriptors[1] =
+{
+  {
+    "message_body",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgProtobufWrapped, has_message_body),
+    offsetof(CMsgProtobufWrapped, message_body),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_protobuf_wrapped__field_indices_by_name[] = {
+  0,   /* field[0] = message_body */
+};
+static const ProtobufCIntRange cmsg_protobuf_wrapped__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_protobuf_wrapped__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgProtobufWrapped",
+  "CMsgProtobufWrapped",
+  "CMsgProtobufWrapped",
+  "",
+  sizeof(CMsgProtobufWrapped),
+  1,
+  cmsg_protobuf_wrapped__field_descriptors,
+  cmsg_protobuf_wrapped__field_indices_by_name,
+  1,  cmsg_protobuf_wrapped__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const uint32_t cmsg_auth_ticket__eresult__default_value = 2u;
+static const ProtobufCFieldDescriptor cmsg_auth_ticket__field_descriptors[8] =
+{
+  {
+    "estate",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgAuthTicket, has_estate),
+    offsetof(CMsgAuthTicket, estate),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "eresult",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgAuthTicket, has_eresult),
+    offsetof(CMsgAuthTicket, eresult),
+    NULL,
+    &cmsg_auth_ticket__eresult__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamid",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgAuthTicket, has_steamid),
+    offsetof(CMsgAuthTicket, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "gameid",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgAuthTicket, has_gameid),
+    offsetof(CMsgAuthTicket, gameid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "h_steam_pipe",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgAuthTicket, has_h_steam_pipe),
+    offsetof(CMsgAuthTicket, h_steam_pipe),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ticket_crc",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgAuthTicket, has_ticket_crc),
+    offsetof(CMsgAuthTicket, ticket_crc),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ticket",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgAuthTicket, has_ticket),
+    offsetof(CMsgAuthTicket, ticket),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "server_secret",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgAuthTicket, has_server_secret),
+    offsetof(CMsgAuthTicket, server_secret),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_auth_ticket__field_indices_by_name[] = {
+  1,   /* field[1] = eresult */
+  0,   /* field[0] = estate */
+  3,   /* field[3] = gameid */
+  4,   /* field[4] = h_steam_pipe */
+  7,   /* field[7] = server_secret */
+  2,   /* field[2] = steamid */
+  6,   /* field[6] = ticket */
+  5,   /* field[5] = ticket_crc */
+};
+static const ProtobufCIntRange cmsg_auth_ticket__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 8 }
+};
+const ProtobufCMessageDescriptor cmsg_auth_ticket__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgAuthTicket",
+  "CMsgAuthTicket",
+  "CMsgAuthTicket",
+  "",
+  sizeof(CMsgAuthTicket),
+  8,
+  cmsg_auth_ticket__field_descriptors,
+  cmsg_auth_ticket__field_indices_by_name,
+  1,  cmsg_auth_ticket__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ccddbapp_detail_common__field_descriptors[15] =
+{
+  {
+    "appid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCDDBAppDetailCommon, has_appid),
+    offsetof(CCDDBAppDetailCommon, appid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "name",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCDDBAppDetailCommon, name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "icon",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCDDBAppDetailCommon, icon),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "tool",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_tool),
+    offsetof(CCDDBAppDetailCommon, tool),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "demo",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_demo),
+    offsetof(CCDDBAppDetailCommon, demo),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "media",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_media),
+    offsetof(CCDDBAppDetailCommon, media),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "community_visible_stats",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_community_visible_stats),
+    offsetof(CCDDBAppDetailCommon, community_visible_stats),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "friendly_name",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCDDBAppDetailCommon, friendly_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "propagation",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCDDBAppDetailCommon, propagation),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "has_adult_content",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_has_adult_content),
+    offsetof(CCDDBAppDetailCommon, has_adult_content),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_visible_in_steam_china",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_is_visible_in_steam_china),
+    offsetof(CCDDBAppDetailCommon, is_visible_in_steam_china),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "app_type",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCDDBAppDetailCommon, has_app_type),
+    offsetof(CCDDBAppDetailCommon, app_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "has_adult_content_sex",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_has_adult_content_sex),
+    offsetof(CCDDBAppDetailCommon, has_adult_content_sex),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "has_adult_content_violence",
+    16,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCDDBAppDetailCommon, has_has_adult_content_violence),
+    offsetof(CCDDBAppDetailCommon, has_adult_content_violence),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "content_descriptorids",
+    17,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCDDBAppDetailCommon, n_content_descriptorids),
+    offsetof(CCDDBAppDetailCommon, content_descriptorids),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccddbapp_detail_common__field_indices_by_name[] = {
+  11,   /* field[11] = app_type */
+  0,   /* field[0] = appid */
+  6,   /* field[6] = community_visible_stats */
+  14,   /* field[14] = content_descriptorids */
+  4,   /* field[4] = demo */
+  7,   /* field[7] = friendly_name */
+  9,   /* field[9] = has_adult_content */
+  12,   /* field[12] = has_adult_content_sex */
+  13,   /* field[13] = has_adult_content_violence */
+  2,   /* field[2] = icon */
+  10,   /* field[10] = is_visible_in_steam_china */
+  5,   /* field[5] = media */
+  1,   /* field[1] = name */
+  8,   /* field[8] = propagation */
+  3,   /* field[3] = tool */
+};
+static const ProtobufCIntRange ccddbapp_detail_common__number_ranges[2 + 1] =
+{
+  { 1, 0 },
+  { 6, 3 },
+  { 0, 15 }
+};
+const ProtobufCMessageDescriptor ccddbapp_detail_common__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCDDBAppDetailCommon",
+  "CCDDBAppDetailCommon",
+  "CCDDBAppDetailCommon",
+  "",
+  sizeof(CCDDBAppDetailCommon),
+  15,
+  ccddbapp_detail_common__field_descriptors,
+  ccddbapp_detail_common__field_indices_by_name,
+  2,  ccddbapp_detail_common__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_app_rights__field_descriptors[17] =
+{
+  {
+    "edit_info",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_edit_info),
+    offsetof(CMsgAppRights, edit_info),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "publish",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_publish),
+    offsetof(CMsgAppRights, publish),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "view_error_data",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_view_error_data),
+    offsetof(CMsgAppRights, view_error_data),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "download",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_download),
+    offsetof(CMsgAppRights, download),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "upload_cdkeys",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_upload_cdkeys),
+    offsetof(CMsgAppRights, upload_cdkeys),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "generate_cdkeys",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_generate_cdkeys),
+    offsetof(CMsgAppRights, generate_cdkeys),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "view_financials",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_view_financials),
+    offsetof(CMsgAppRights, view_financials),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "manage_ceg",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_manage_ceg),
+    offsetof(CMsgAppRights, manage_ceg),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "manage_signing",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_manage_signing),
+    offsetof(CMsgAppRights, manage_signing),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "manage_cdkeys",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_manage_cdkeys),
+    offsetof(CMsgAppRights, manage_cdkeys),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "edit_marketing",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_edit_marketing),
+    offsetof(CMsgAppRights, edit_marketing),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "economy_support",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_economy_support),
+    offsetof(CMsgAppRights, economy_support),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "economy_support_supervisor",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_economy_support_supervisor),
+    offsetof(CMsgAppRights, economy_support_supervisor),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "manage_pricing",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_manage_pricing),
+    offsetof(CMsgAppRights, manage_pricing),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "broadcast_live",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_broadcast_live),
+    offsetof(CMsgAppRights, broadcast_live),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "view_marketing_traffic",
+    16,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_view_marketing_traffic),
+    offsetof(CMsgAppRights, view_marketing_traffic),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "edit_store_display_content",
+    17,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgAppRights, has_edit_store_display_content),
+    offsetof(CMsgAppRights, edit_store_display_content),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_app_rights__field_indices_by_name[] = {
+  14,   /* field[14] = broadcast_live */
+  3,   /* field[3] = download */
+  11,   /* field[11] = economy_support */
+  12,   /* field[12] = economy_support_supervisor */
+  0,   /* field[0] = edit_info */
+  10,   /* field[10] = edit_marketing */
+  16,   /* field[16] = edit_store_display_content */
+  5,   /* field[5] = generate_cdkeys */
+  9,   /* field[9] = manage_cdkeys */
+  7,   /* field[7] = manage_ceg */
+  13,   /* field[13] = manage_pricing */
+  8,   /* field[8] = manage_signing */
+  1,   /* field[1] = publish */
+  4,   /* field[4] = upload_cdkeys */
+  2,   /* field[2] = view_error_data */
+  6,   /* field[6] = view_financials */
+  15,   /* field[15] = view_marketing_traffic */
+};
+static const ProtobufCIntRange cmsg_app_rights__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 17 }
+};
+const ProtobufCMessageDescriptor cmsg_app_rights__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgAppRights",
+  "CMsgAppRights",
+  "CMsgAppRights",
+  "",
+  sizeof(CMsgAppRights),
+  17,
+  cmsg_app_rights__field_descriptors,
+  cmsg_app_rights__field_indices_by_name,
+  1,  cmsg_app_rights__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ccurator_preferences__field_descriptors[14] =
+{
+  {
+    "supported_languages",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCuratorPreferences, has_supported_languages),
+    offsetof(CCuratorPreferences, supported_languages),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_windows",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCuratorPreferences, has_platform_windows),
+    offsetof(CCuratorPreferences, platform_windows),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_mac",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCuratorPreferences, has_platform_mac),
+    offsetof(CCuratorPreferences, platform_mac),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "platform_linux",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCuratorPreferences, has_platform_linux),
+    offsetof(CCuratorPreferences, platform_linux),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "vr_content",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCuratorPreferences, has_vr_content),
+    offsetof(CCuratorPreferences, vr_content),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "adult_content_violence",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCuratorPreferences, has_adult_content_violence),
+    offsetof(CCuratorPreferences, adult_content_violence),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "adult_content_sex",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCuratorPreferences, has_adult_content_sex),
+    offsetof(CCuratorPreferences, adult_content_sex),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "timestamp_updated",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCuratorPreferences, has_timestamp_updated),
+    offsetof(CCuratorPreferences, timestamp_updated),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "tagids_curated",
+    9,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCuratorPreferences, n_tagids_curated),
+    offsetof(CCuratorPreferences, tagids_curated),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "tagids_filtered",
+    10,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCuratorPreferences, n_tagids_filtered),
+    offsetof(CCuratorPreferences, tagids_filtered),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "website_title",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCuratorPreferences, website_title),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "website_url",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCuratorPreferences, website_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "discussion_url",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCuratorPreferences, discussion_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "show_broadcast",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCuratorPreferences, has_show_broadcast),
+    offsetof(CCuratorPreferences, show_broadcast),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccurator_preferences__field_indices_by_name[] = {
+  6,   /* field[6] = adult_content_sex */
+  5,   /* field[5] = adult_content_violence */
+  12,   /* field[12] = discussion_url */
+  3,   /* field[3] = platform_linux */
+  2,   /* field[2] = platform_mac */
+  1,   /* field[1] = platform_windows */
+  13,   /* field[13] = show_broadcast */
+  0,   /* field[0] = supported_languages */
+  8,   /* field[8] = tagids_curated */
+  9,   /* field[9] = tagids_filtered */
+  7,   /* field[7] = timestamp_updated */
+  4,   /* field[4] = vr_content */
+  10,   /* field[10] = website_title */
+  11,   /* field[11] = website_url */
+};
+static const ProtobufCIntRange ccurator_preferences__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 14 }
+};
+const ProtobufCMessageDescriptor ccurator_preferences__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCuratorPreferences",
+  "CCuratorPreferences",
+  "CCuratorPreferences",
+  "",
+  sizeof(CCuratorPreferences),
+  14,
+  ccurator_preferences__field_descriptors,
+  ccurator_preferences__field_indices_by_name,
+  1,  ccurator_preferences__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor clocalization_token__field_descriptors[2] =
+{
+  {
+    "language",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CLocalizationToken, has_language),
+    offsetof(CLocalizationToken, language),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "localized_string",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CLocalizationToken, localized_string),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned clocalization_token__field_indices_by_name[] = {
+  0,   /* field[0] = language */
+  1,   /* field[1] = localized_string */
+};
+static const ProtobufCIntRange clocalization_token__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor clocalization_token__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CLocalizationToken",
+  "CLocalizationToken",
+  "CLocalizationToken",
+  "",
+  sizeof(CLocalizationToken),
+  2,
+  clocalization_token__field_descriptors,
+  clocalization_token__field_indices_by_name,
+  1,  clocalization_token__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cclan_event_user_news_tuple__field_descriptors[10] =
+{
+  {
+    "clanid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_clanid),
+    offsetof(CClanEventUserNewsTuple, clanid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "event_gid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventUserNewsTuple, has_event_gid),
+    offsetof(CClanEventUserNewsTuple, event_gid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "announcement_gid",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventUserNewsTuple, has_announcement_gid),
+    offsetof(CClanEventUserNewsTuple, announcement_gid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime_start",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_rtime_start),
+    offsetof(CClanEventUserNewsTuple, rtime_start),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime_end",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_rtime_end),
+    offsetof(CClanEventUserNewsTuple, rtime_end),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "priority_score",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_priority_score),
+    offsetof(CClanEventUserNewsTuple, priority_score),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "type",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_type),
+    offsetof(CClanEventUserNewsTuple, type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "clamp_range_slot",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_clamp_range_slot),
+    offsetof(CClanEventUserNewsTuple, clamp_range_slot),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "appid",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_appid),
+    offsetof(CClanEventUserNewsTuple, appid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_last_modified",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventUserNewsTuple, has_rtime32_last_modified),
+    offsetof(CClanEventUserNewsTuple, rtime32_last_modified),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cclan_event_user_news_tuple__field_indices_by_name[] = {
+  2,   /* field[2] = announcement_gid */
+  8,   /* field[8] = appid */
+  7,   /* field[7] = clamp_range_slot */
+  0,   /* field[0] = clanid */
+  1,   /* field[1] = event_gid */
+  5,   /* field[5] = priority_score */
+  9,   /* field[9] = rtime32_last_modified */
+  4,   /* field[4] = rtime_end */
+  3,   /* field[3] = rtime_start */
+  6,   /* field[6] = type */
+};
+static const ProtobufCIntRange cclan_event_user_news_tuple__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 10 }
+};
+const ProtobufCMessageDescriptor cclan_event_user_news_tuple__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CClanEventUserNewsTuple",
+  "CClanEventUserNewsTuple",
+  "CClanEventUserNewsTuple",
+  "",
+  sizeof(CClanEventUserNewsTuple),
+  10,
+  cclan_event_user_news_tuple__field_descriptors,
+  cclan_event_user_news_tuple__field_indices_by_name,
+  1,  cclan_event_user_news_tuple__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cclan_match_event_by_range__field_descriptors[4] =
+{
+  {
+    "rtime_before",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanMatchEventByRange, has_rtime_before),
+    offsetof(CClanMatchEventByRange, rtime_before),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime_after",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanMatchEventByRange, has_rtime_after),
+    offsetof(CClanMatchEventByRange, rtime_after),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "qualified",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanMatchEventByRange, has_qualified),
+    offsetof(CClanMatchEventByRange, qualified),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "events",
+    4,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CClanMatchEventByRange, n_events),
+    offsetof(CClanMatchEventByRange, events),
+    &cclan_event_user_news_tuple__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cclan_match_event_by_range__field_indices_by_name[] = {
+  3,   /* field[3] = events */
+  2,   /* field[2] = qualified */
+  1,   /* field[1] = rtime_after */
+  0,   /* field[0] = rtime_before */
+};
+static const ProtobufCIntRange cclan_match_event_by_range__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 4 }
+};
+const ProtobufCMessageDescriptor cclan_match_event_by_range__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CClanMatchEventByRange",
+  "CClanMatchEventByRange",
+  "CClanMatchEventByRange",
+  "",
+  sizeof(CClanMatchEventByRange),
+  4,
+  cclan_match_event_by_range__field_descriptors,
+  cclan_match_event_by_range__field_indices_by_name,
+  1,  cclan_match_event_by_range__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EBanContentCheckResult ccommunity__clan_announcement_info__ban_check_result__default_value = EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_NotScanned;
+static const ProtobufCFieldDescriptor ccommunity__clan_announcement_info__field_descriptors[17] =
+{
+  {
+    "gid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CCommunityClanAnnouncementInfo, has_gid),
+    offsetof(CCommunityClanAnnouncementInfo, gid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "clanid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CCommunityClanAnnouncementInfo, has_clanid),
+    offsetof(CCommunityClanAnnouncementInfo, clanid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "posterid",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CCommunityClanAnnouncementInfo, has_posterid),
+    offsetof(CCommunityClanAnnouncementInfo, posterid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "headline",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCommunityClanAnnouncementInfo, headline),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "posttime",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCommunityClanAnnouncementInfo, has_posttime),
+    offsetof(CCommunityClanAnnouncementInfo, posttime),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "updatetime",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CCommunityClanAnnouncementInfo, has_updatetime),
+    offsetof(CCommunityClanAnnouncementInfo, updatetime),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "body",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CCommunityClanAnnouncementInfo, body),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "commentcount",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CCommunityClanAnnouncementInfo, has_commentcount),
+    offsetof(CCommunityClanAnnouncementInfo, commentcount),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "tags",
+    9,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_STRING,
+    offsetof(CCommunityClanAnnouncementInfo, n_tags),
+    offsetof(CCommunityClanAnnouncementInfo, tags),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "language",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CCommunityClanAnnouncementInfo, has_language),
+    offsetof(CCommunityClanAnnouncementInfo, language),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "hidden",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCommunityClanAnnouncementInfo, has_hidden),
+    offsetof(CCommunityClanAnnouncementInfo, hidden),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "forum_topic_id",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CCommunityClanAnnouncementInfo, has_forum_topic_id),
+    offsetof(CCommunityClanAnnouncementInfo, forum_topic_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "event_gid",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CCommunityClanAnnouncementInfo, has_event_gid),
+    offsetof(CCommunityClanAnnouncementInfo, event_gid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "voteupcount",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CCommunityClanAnnouncementInfo, has_voteupcount),
+    offsetof(CCommunityClanAnnouncementInfo, voteupcount),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "votedowncount",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CCommunityClanAnnouncementInfo, has_votedowncount),
+    offsetof(CCommunityClanAnnouncementInfo, votedowncount),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ban_check_result",
+    16,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CCommunityClanAnnouncementInfo, has_ban_check_result),
+    offsetof(CCommunityClanAnnouncementInfo, ban_check_result),
+    &eban_content_check_result__descriptor,
+    &ccommunity__clan_announcement_info__ban_check_result__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "banned",
+    17,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CCommunityClanAnnouncementInfo, has_banned),
+    offsetof(CCommunityClanAnnouncementInfo, banned),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ccommunity__clan_announcement_info__field_indices_by_name[] = {
+  15,   /* field[15] = ban_check_result */
+  16,   /* field[16] = banned */
+  6,   /* field[6] = body */
+  1,   /* field[1] = clanid */
+  7,   /* field[7] = commentcount */
+  12,   /* field[12] = event_gid */
+  11,   /* field[11] = forum_topic_id */
+  0,   /* field[0] = gid */
+  3,   /* field[3] = headline */
+  10,   /* field[10] = hidden */
+  9,   /* field[9] = language */
+  2,   /* field[2] = posterid */
+  4,   /* field[4] = posttime */
+  8,   /* field[8] = tags */
+  5,   /* field[5] = updatetime */
+  14,   /* field[14] = votedowncount */
+  13,   /* field[13] = voteupcount */
+};
+static const ProtobufCIntRange ccommunity__clan_announcement_info__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 17 }
+};
+const ProtobufCMessageDescriptor ccommunity__clan_announcement_info__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CCommunity_ClanAnnouncementInfo",
+  "CCommunityClanAnnouncementInfo",
+  "CCommunityClanAnnouncementInfo",
+  "",
+  sizeof(CCommunityClanAnnouncementInfo),
+  17,
+  ccommunity__clan_announcement_info__field_descriptors,
+  ccommunity__clan_announcement_info__field_indices_by_name,
+  1,  ccommunity__clan_announcement_info__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const EProtoClanEventType cclan_event_data__event_type__default_value = EPROTO_CLAN_EVENT_TYPE__k_EClanOtherEvent;
+static const ProtobufCFieldDescriptor cclan_event_data__field_descriptors[30] =
+{
+  {
+    "gid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventData, has_gid),
+    offsetof(CClanEventData, gid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "clan_steamid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventData, has_clan_steamid),
+    offsetof(CClanEventData, clan_steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "event_name",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CClanEventData, event_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "event_type",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CClanEventData, has_event_type),
+    offsetof(CClanEventData, event_type),
+    &eproto_clan_event_type__descriptor,
+    &cclan_event_data__event_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "appid",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_appid),
+    offsetof(CClanEventData, appid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "server_address",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CClanEventData, server_address),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "server_password",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CClanEventData, server_password),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_start_time",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_rtime32_start_time),
+    offsetof(CClanEventData, rtime32_start_time),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_end_time",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_rtime32_end_time),
+    offsetof(CClanEventData, rtime32_end_time),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "comment_count",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CClanEventData, has_comment_count),
+    offsetof(CClanEventData, comment_count),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "creator_steamid",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventData, has_creator_steamid),
+    offsetof(CClanEventData, creator_steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "last_update_steamid",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventData, has_last_update_steamid),
+    offsetof(CClanEventData, last_update_steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "event_notes",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CClanEventData, event_notes),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "jsondata",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CClanEventData, jsondata),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "announcement_body",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CClanEventData, announcement_body),
+    &ccommunity__clan_announcement_info__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "published",
+    16,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CClanEventData, has_published),
+    offsetof(CClanEventData, published),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "hidden",
+    17,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CClanEventData, has_hidden),
+    offsetof(CClanEventData, hidden),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_visibility_start",
+    18,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_rtime32_visibility_start),
+    offsetof(CClanEventData, rtime32_visibility_start),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_visibility_end",
+    19,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_rtime32_visibility_end),
+    offsetof(CClanEventData, rtime32_visibility_end),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "broadcaster_accountid",
+    20,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_broadcaster_accountid),
+    offsetof(CClanEventData, broadcaster_accountid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "follower_count",
+    21,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_follower_count),
+    offsetof(CClanEventData, follower_count),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ignore_count",
+    22,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_ignore_count),
+    offsetof(CClanEventData, ignore_count),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "forum_topic_id",
+    23,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventData, has_forum_topic_id),
+    offsetof(CClanEventData, forum_topic_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_last_modified",
+    24,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_rtime32_last_modified),
+    offsetof(CClanEventData, rtime32_last_modified),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "news_post_gid",
+    25,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CClanEventData, has_news_post_gid),
+    offsetof(CClanEventData, news_post_gid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime_mod_reviewed",
+    26,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_rtime_mod_reviewed),
+    offsetof(CClanEventData, rtime_mod_reviewed),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "featured_app_tagid",
+    27,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_featured_app_tagid),
+    offsetof(CClanEventData, featured_app_tagid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "referenced_appids",
+    28,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, n_referenced_appids),
+    offsetof(CClanEventData, referenced_appids),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "build_id",
+    29,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CClanEventData, has_build_id),
+    offsetof(CClanEventData, build_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "build_branch",
+    30,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CClanEventData, build_branch),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cclan_event_data__field_indices_by_name[] = {
+  14,   /* field[14] = announcement_body */
+  4,   /* field[4] = appid */
+  19,   /* field[19] = broadcaster_accountid */
+  29,   /* field[29] = build_branch */
+  28,   /* field[28] = build_id */
+  1,   /* field[1] = clan_steamid */
+  9,   /* field[9] = comment_count */
+  10,   /* field[10] = creator_steamid */
+  2,   /* field[2] = event_name */
+  12,   /* field[12] = event_notes */
+  3,   /* field[3] = event_type */
+  26,   /* field[26] = featured_app_tagid */
+  20,   /* field[20] = follower_count */
+  22,   /* field[22] = forum_topic_id */
+  0,   /* field[0] = gid */
+  16,   /* field[16] = hidden */
+  21,   /* field[21] = ignore_count */
+  13,   /* field[13] = jsondata */
+  11,   /* field[11] = last_update_steamid */
+  24,   /* field[24] = news_post_gid */
+  15,   /* field[15] = published */
+  27,   /* field[27] = referenced_appids */
+  8,   /* field[8] = rtime32_end_time */
+  23,   /* field[23] = rtime32_last_modified */
+  7,   /* field[7] = rtime32_start_time */
+  18,   /* field[18] = rtime32_visibility_end */
+  17,   /* field[17] = rtime32_visibility_start */
+  25,   /* field[25] = rtime_mod_reviewed */
+  5,   /* field[5] = server_address */
+  6,   /* field[6] = server_password */
+};
+static const ProtobufCIntRange cclan_event_data__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 30 }
+};
+const ProtobufCMessageDescriptor cclan_event_data__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CClanEventData",
+  "CClanEventData",
+  "CClanEventData",
+  "",
+  sizeof(CClanEventData),
+  30,
+  cclan_event_data__field_descriptors,
+  cclan_event_data__field_indices_by_name,
+  1,  cclan_event_data__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cbilling__address__field_descriptors[10] =
+{
+  {
+    "first_name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, first_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "last_name",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, last_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "address1",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, address1),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "address2",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, address2),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "city",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, city),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "us_state",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, us_state),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "country_code",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, country_code),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "postcode",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, postcode),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "zip_plus4",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CBillingAddress, has_zip_plus4),
+    offsetof(CBillingAddress, zip_plus4),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "phone",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CBillingAddress, phone),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cbilling__address__field_indices_by_name[] = {
+  2,   /* field[2] = address1 */
+  3,   /* field[3] = address2 */
+  4,   /* field[4] = city */
+  6,   /* field[6] = country_code */
+  0,   /* field[0] = first_name */
+  1,   /* field[1] = last_name */
+  9,   /* field[9] = phone */
+  7,   /* field[7] = postcode */
+  5,   /* field[5] = us_state */
+  8,   /* field[8] = zip_plus4 */
+};
+static const ProtobufCIntRange cbilling__address__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 10 }
+};
+const ProtobufCMessageDescriptor cbilling__address__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CBilling_Address",
+  "CBillingAddress",
+  "CBillingAddress",
+  "",
+  sizeof(CBillingAddress),
+  10,
+  cbilling__address__field_descriptors,
+  cbilling__address__field_indices_by_name,
+  1,  cbilling__address__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cpackage_reservation_status__field_descriptors[8] =
+{
+  {
+    "packageid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CPackageReservationStatus, has_packageid),
+    offsetof(CPackageReservationStatus, packageid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "reservation_state",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CPackageReservationStatus, has_reservation_state),
+    offsetof(CPackageReservationStatus, reservation_state),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "queue_position",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CPackageReservationStatus, has_queue_position),
+    offsetof(CPackageReservationStatus, queue_position),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "total_queue_size",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CPackageReservationStatus, has_total_queue_size),
+    offsetof(CPackageReservationStatus, total_queue_size),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "reservation_country_code",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CPackageReservationStatus, reservation_country_code),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "expired",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CPackageReservationStatus, has_expired),
+    offsetof(CPackageReservationStatus, expired),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "time_expires",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CPackageReservationStatus, has_time_expires),
+    offsetof(CPackageReservationStatus, time_expires),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "time_reserved",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CPackageReservationStatus, has_time_reserved),
+    offsetof(CPackageReservationStatus, time_reserved),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cpackage_reservation_status__field_indices_by_name[] = {
+  5,   /* field[5] = expired */
+  0,   /* field[0] = packageid */
+  2,   /* field[2] = queue_position */
+  4,   /* field[4] = reservation_country_code */
+  1,   /* field[1] = reservation_state */
+  6,   /* field[6] = time_expires */
+  7,   /* field[7] = time_reserved */
+  3,   /* field[3] = total_queue_size */
+};
+static const ProtobufCIntRange cpackage_reservation_status__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 8 }
+};
+const ProtobufCMessageDescriptor cpackage_reservation_status__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CPackageReservationStatus",
+  "CPackageReservationStatus",
+  "CPackageReservationStatus",
+  "",
+  sizeof(CPackageReservationStatus),
+  8,
+  cpackage_reservation_status__field_descriptors,
+  cpackage_reservation_status__field_indices_by_name,
+  1,  cpackage_reservation_status__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_key_value_pair__field_descriptors[2] =
+{
+  {
+    "name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgKeyValuePair, name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "value",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgKeyValuePair, value),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_key_value_pair__field_indices_by_name[] = {
+  0,   /* field[0] = name */
+  1,   /* field[1] = value */
+};
+static const ProtobufCIntRange cmsg_key_value_pair__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cmsg_key_value_pair__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgKeyValuePair",
+  "CMsgKeyValuePair",
+  "CMsgKeyValuePair",
+  "",
+  sizeof(CMsgKeyValuePair),
+  2,
+  cmsg_key_value_pair__field_descriptors,
+  cmsg_key_value_pair__field_indices_by_name,
+  1,  cmsg_key_value_pair__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_key_value_set__field_descriptors[1] =
+{
+  {
+    "pairs",
+    1,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(CMsgKeyValueSet, n_pairs),
+    offsetof(CMsgKeyValueSet, pairs),
+    &cmsg_key_value_pair__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_key_value_set__field_indices_by_name[] = {
+  0,   /* field[0] = pairs */
+};
+static const ProtobufCIntRange cmsg_key_value_set__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_key_value_set__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgKeyValueSet",
+  "CMsgKeyValueSet",
+  "CMsgKeyValueSet",
+  "",
+  sizeof(CMsgKeyValueSet),
+  1,
+  cmsg_key_value_set__field_descriptors,
+  cmsg_key_value_set__field_indices_by_name,
+  1,  cmsg_key_value_set__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCEnumValue eban_content_check_result__enum_values_by_number[8] =
+{
+  { "k_EBanContentCheckResult_NotScanned", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_NotScanned", 0 },
+  { "k_EBanContentCheckResult_Reset", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Reset", 1 },
+  { "k_EBanContentCheckResult_NeedsChecking", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_NeedsChecking", 2 },
+  { "k_EBanContentCheckResult_VeryUnlikely", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_VeryUnlikely", 5 },
+  { "k_EBanContentCheckResult_Unlikely", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Unlikely", 30 },
+  { "k_EBanContentCheckResult_Possible", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Possible", 50 },
+  { "k_EBanContentCheckResult_Likely", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Likely", 75 },
+  { "k_EBanContentCheckResult_VeryLikely", "EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_VeryLikely", 100 },
+};
+static const ProtobufCIntRange eban_content_check_result__value_ranges[] = {
+{0, 0},{5, 3},{30, 4},{50, 5},{75, 6},{100, 7},{0, 8}
+};
+static const ProtobufCEnumValueIndex eban_content_check_result__enum_values_by_name[8] =
+{
+  { "k_EBanContentCheckResult_Likely", 6 },
+  { "k_EBanContentCheckResult_NeedsChecking", 2 },
+  { "k_EBanContentCheckResult_NotScanned", 0 },
+  { "k_EBanContentCheckResult_Possible", 5 },
+  { "k_EBanContentCheckResult_Reset", 1 },
+  { "k_EBanContentCheckResult_Unlikely", 4 },
+  { "k_EBanContentCheckResult_VeryLikely", 7 },
+  { "k_EBanContentCheckResult_VeryUnlikely", 3 },
+};
+const ProtobufCEnumDescriptor eban_content_check_result__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EBanContentCheckResult",
+  "EBanContentCheckResult",
+  "EBanContentCheckResult",
+  "",
+  8,
+  eban_content_check_result__enum_values_by_number,
+  8,
+  eban_content_check_result__enum_values_by_name,
+  6,
+  eban_content_check_result__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue eproto_clan_event_type__enum_values_by_number[35] =
+{
+  { "k_EClanOtherEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanOtherEvent", 1 },
+  { "k_EClanGameEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanGameEvent", 2 },
+  { "k_EClanPartyEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanPartyEvent", 3 },
+  { "k_EClanMeetingEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanMeetingEvent", 4 },
+  { "k_EClanSpecialCauseEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanSpecialCauseEvent", 5 },
+  { "k_EClanMusicAndArtsEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanMusicAndArtsEvent", 6 },
+  { "k_EClanSportsEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanSportsEvent", 7 },
+  { "k_EClanTripEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanTripEvent", 8 },
+  { "k_EClanChatEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanChatEvent", 9 },
+  { "k_EClanGameReleaseEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanGameReleaseEvent", 10 },
+  { "k_EClanBroadcastEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanBroadcastEvent", 11 },
+  { "k_EClanSmallUpdateEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanSmallUpdateEvent", 12 },
+  { "k_EClanPreAnnounceMajorUpdateEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanPreAnnounceMajorUpdateEvent", 13 },
+  { "k_EClanMajorUpdateEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanMajorUpdateEvent", 14 },
+  { "k_EClanDLCReleaseEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanDLCReleaseEvent", 15 },
+  { "k_EClanFutureReleaseEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanFutureReleaseEvent", 16 },
+  { "k_EClanESportTournamentStreamEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanESportTournamentStreamEvent", 17 },
+  { "k_EClanDevStreamEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanDevStreamEvent", 18 },
+  { "k_EClanFamousStreamEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanFamousStreamEvent", 19 },
+  { "k_EClanGameSalesEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanGameSalesEvent", 20 },
+  { "k_EClanGameItemSalesEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanGameItemSalesEvent", 21 },
+  { "k_EClanInGameBonusXPEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanInGameBonusXPEvent", 22 },
+  { "k_EClanInGameLootEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanInGameLootEvent", 23 },
+  { "k_EClanInGamePerksEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanInGamePerksEvent", 24 },
+  { "k_EClanInGameChallengeEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanInGameChallengeEvent", 25 },
+  { "k_EClanInGameContestEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanInGameContestEvent", 26 },
+  { "k_EClanIRLEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanIRLEvent", 27 },
+  { "k_EClanNewsEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanNewsEvent", 28 },
+  { "k_EClanBetaReleaseEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanBetaReleaseEvent", 29 },
+  { "k_EClanInGameContentReleaseEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanInGameContentReleaseEvent", 30 },
+  { "k_EClanFreeTrial", "EPROTO_CLAN_EVENT_TYPE__k_EClanFreeTrial", 31 },
+  { "k_EClanSeasonRelease", "EPROTO_CLAN_EVENT_TYPE__k_EClanSeasonRelease", 32 },
+  { "k_EClanSeasonUpdate", "EPROTO_CLAN_EVENT_TYPE__k_EClanSeasonUpdate", 33 },
+  { "k_EClanCrosspostEvent", "EPROTO_CLAN_EVENT_TYPE__k_EClanCrosspostEvent", 34 },
+  { "k_EClanInGameEventGeneral", "EPROTO_CLAN_EVENT_TYPE__k_EClanInGameEventGeneral", 35 },
+};
+static const ProtobufCIntRange eproto_clan_event_type__value_ranges[] = {
+{1, 0},{0, 35}
+};
+static const ProtobufCEnumValueIndex eproto_clan_event_type__enum_values_by_name[35] =
+{
+  { "k_EClanBetaReleaseEvent", 28 },
+  { "k_EClanBroadcastEvent", 10 },
+  { "k_EClanChatEvent", 8 },
+  { "k_EClanCrosspostEvent", 33 },
+  { "k_EClanDLCReleaseEvent", 14 },
+  { "k_EClanDevStreamEvent", 17 },
+  { "k_EClanESportTournamentStreamEvent", 16 },
+  { "k_EClanFamousStreamEvent", 18 },
+  { "k_EClanFreeTrial", 30 },
+  { "k_EClanFutureReleaseEvent", 15 },
+  { "k_EClanGameEvent", 1 },
+  { "k_EClanGameItemSalesEvent", 20 },
+  { "k_EClanGameReleaseEvent", 9 },
+  { "k_EClanGameSalesEvent", 19 },
+  { "k_EClanIRLEvent", 26 },
+  { "k_EClanInGameBonusXPEvent", 21 },
+  { "k_EClanInGameChallengeEvent", 24 },
+  { "k_EClanInGameContentReleaseEvent", 29 },
+  { "k_EClanInGameContestEvent", 25 },
+  { "k_EClanInGameEventGeneral", 34 },
+  { "k_EClanInGameLootEvent", 22 },
+  { "k_EClanInGamePerksEvent", 23 },
+  { "k_EClanMajorUpdateEvent", 13 },
+  { "k_EClanMeetingEvent", 3 },
+  { "k_EClanMusicAndArtsEvent", 5 },
+  { "k_EClanNewsEvent", 27 },
+  { "k_EClanOtherEvent", 0 },
+  { "k_EClanPartyEvent", 2 },
+  { "k_EClanPreAnnounceMajorUpdateEvent", 12 },
+  { "k_EClanSeasonRelease", 31 },
+  { "k_EClanSeasonUpdate", 32 },
+  { "k_EClanSmallUpdateEvent", 11 },
+  { "k_EClanSpecialCauseEvent", 4 },
+  { "k_EClanSportsEvent", 6 },
+  { "k_EClanTripEvent", 7 },
+};
+const ProtobufCEnumDescriptor eproto_clan_event_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EProtoClanEventType",
+  "EProtoClanEventType",
+  "EProtoClanEventType",
+  "",
+  35,
+  eproto_clan_event_type__enum_values_by_number,
+  35,
+  eproto_clan_event_type__enum_values_by_name,
+  1,
+  eproto_clan_event_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
+static const ProtobufCEnumValue partner_event_notification_type__enum_values_by_number[4] =
+{
+  { "k_EEventStart", "PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventStart", 0 },
+  { "k_EEventBroadcastStart", "PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventBroadcastStart", 1 },
+  { "k_EEventMatchStart", "PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventMatchStart", 2 },
+  { "k_EEventPartnerMaxType", "PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventPartnerMaxType", 3 },
+};
+static const ProtobufCIntRange partner_event_notification_type__value_ranges[] = {
+{0, 0},{0, 4}
+};
+static const ProtobufCEnumValueIndex partner_event_notification_type__enum_values_by_name[4] =
+{
+  { "k_EEventBroadcastStart", 1 },
+  { "k_EEventMatchStart", 2 },
+  { "k_EEventPartnerMaxType", 3 },
+  { "k_EEventStart", 0 },
+};
+const ProtobufCEnumDescriptor partner_event_notification_type__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "PartnerEventNotificationType",
+  "PartnerEventNotificationType",
+  "PartnerEventNotificationType",
+  "",
+  4,
+  partner_event_notification_type__enum_values_by_number,
+  4,
+  partner_event_notification_type__enum_values_by_name,
+  1,
+  partner_event_notification_type__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
diff --git a/protocols/Steam/src/protobuf-c/steammessages_base.pb-c.h b/protocols/Steam/src/protobuf-c/steammessages_base.pb-c.h
new file mode 100644
index 0000000000..4ff94b1524
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_base.pb-c.h
@@ -0,0 +1,982 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_base.proto */
+
+#ifndef PROTOBUF_C_steammessages_5fbase_2eproto__INCLUDED
+#define PROTOBUF_C_steammessages_5fbase_2eproto__INCLUDED
+
+#include "protobuf-c.h"
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1000000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+struct CMsgIPAddress;
+struct CMsgIPAddressBucket;
+struct CMsgGCRoutingProtoBufHeader;
+struct CMsgProtoBufHeader;
+struct CMsgMulti;
+struct CMsgProtobufWrapped;
+struct CMsgAuthTicket;
+struct CCDDBAppDetailCommon;
+struct CMsgAppRights;
+struct CCuratorPreferences;
+struct CLocalizationToken;
+struct CClanEventUserNewsTuple;
+struct CClanMatchEventByRange;
+struct CCommunityClanAnnouncementInfo;
+struct CClanEventData;
+struct CBillingAddress;
+struct CPackageReservationStatus;
+struct CMsgKeyValuePair;
+struct CMsgKeyValueSet;
+
+
+/* --- enums --- */
+
+typedef enum _EBanContentCheckResult {
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_NotScanned = 0,
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Reset = 1,
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_NeedsChecking = 2,
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_VeryUnlikely = 5,
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Unlikely = 30,
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Possible = 50,
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_Likely = 75,
+  EBAN_CONTENT_CHECK_RESULT__k_EBanContentCheckResult_VeryLikely = 100
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EBAN_CONTENT_CHECK_RESULT)
+} EBanContentCheckResult;
+typedef enum _EProtoClanEventType {
+  EPROTO_CLAN_EVENT_TYPE__k_EClanOtherEvent = 1,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanGameEvent = 2,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanPartyEvent = 3,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanMeetingEvent = 4,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanSpecialCauseEvent = 5,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanMusicAndArtsEvent = 6,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanSportsEvent = 7,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanTripEvent = 8,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanChatEvent = 9,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanGameReleaseEvent = 10,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanBroadcastEvent = 11,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanSmallUpdateEvent = 12,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanPreAnnounceMajorUpdateEvent = 13,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanMajorUpdateEvent = 14,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanDLCReleaseEvent = 15,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanFutureReleaseEvent = 16,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanESportTournamentStreamEvent = 17,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanDevStreamEvent = 18,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanFamousStreamEvent = 19,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanGameSalesEvent = 20,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanGameItemSalesEvent = 21,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanInGameBonusXPEvent = 22,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanInGameLootEvent = 23,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanInGamePerksEvent = 24,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanInGameChallengeEvent = 25,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanInGameContestEvent = 26,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanIRLEvent = 27,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanNewsEvent = 28,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanBetaReleaseEvent = 29,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanInGameContentReleaseEvent = 30,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanFreeTrial = 31,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanSeasonRelease = 32,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanSeasonUpdate = 33,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanCrosspostEvent = 34,
+  EPROTO_CLAN_EVENT_TYPE__k_EClanInGameEventGeneral = 35
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPROTO_CLAN_EVENT_TYPE)
+} EProtoClanEventType;
+typedef enum _PartnerEventNotificationType {
+  PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventStart = 0,
+  PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventBroadcastStart = 1,
+  PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventMatchStart = 2,
+  PARTNER_EVENT_NOTIFICATION_TYPE__k_EEventPartnerMaxType = 3
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(PARTNER_EVENT_NOTIFICATION_TYPE)
+} PartnerEventNotificationType;
+
+/* --- descriptors --- */
+
+extern const ProtobufCEnumDescriptor    eban_content_check_result__descriptor;
+extern const ProtobufCEnumDescriptor    eproto_clan_event_type__descriptor;
+extern const ProtobufCEnumDescriptor    partner_event_notification_type__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_ipaddress__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_ipaddress_bucket__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_gcrouting_proto_buf_header__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_proto_buf_header__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_multi__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_protobuf_wrapped__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_auth_ticket__descriptor;
+extern const ProtobufCMessageDescriptor ccddbapp_detail_common__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_app_rights__descriptor;
+extern const ProtobufCMessageDescriptor ccurator_preferences__descriptor;
+extern const ProtobufCMessageDescriptor clocalization_token__descriptor;
+extern const ProtobufCMessageDescriptor cclan_event_user_news_tuple__descriptor;
+extern const ProtobufCMessageDescriptor cclan_match_event_by_range__descriptor;
+extern const ProtobufCMessageDescriptor ccommunity__clan_announcement_info__descriptor;
+extern const ProtobufCMessageDescriptor cclan_event_data__descriptor;
+extern const ProtobufCMessageDescriptor cbilling__address__descriptor;
+extern const ProtobufCMessageDescriptor cpackage_reservation_status__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_key_value_pair__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_key_value_set__descriptor;
+
+/* --- messages --- */
+
+typedef enum {
+  CMSG_IPADDRESS__IP__NOT_SET = 0,
+  CMSG_IPADDRESS__IP_V4 = 1,
+  CMSG_IPADDRESS__IP_V6 = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(CMSG_IPADDRESS__IP__CASE)
+} CMsgIPAddress__IpCase;
+
+struct CMsgIPAddress : public ProtobufCppMessage
+{
+  CMsgIPAddress() :
+     ProtobufCppMessage(cmsg_ipaddress__descriptor)
+  {}
+
+  CMsgIPAddress__IpCase ip_case;
+  union {
+    uint32_t v4;
+    ProtobufCBinaryData v6;
+  };
+};
+
+struct CMsgIPAddressBucket : public ProtobufCppMessage
+{
+  CMsgIPAddressBucket() :
+     ProtobufCppMessage(cmsg_ipaddress_bucket__descriptor)
+  {}
+
+  CMsgIPAddress *original_ip_address;
+  protobuf_c_boolean has_bucket;
+  uint64_t bucket;
+};
+
+struct CMsgGCRoutingProtoBufHeader : public ProtobufCppMessage
+{
+  CMsgGCRoutingProtoBufHeader() :
+     ProtobufCppMessage(cmsg_gcrouting_proto_buf_header__descriptor)
+  {}
+
+  protobuf_c_boolean has_dst_gcid_queue;
+  uint64_t dst_gcid_queue;
+  protobuf_c_boolean has_dst_gc_dir_index;
+  uint32_t dst_gc_dir_index;
+};
+
+typedef enum {
+  CMSG_PROTO_BUF_HEADER__IP_ADDR__NOT_SET = 0,
+  CMSG_PROTO_BUF_HEADER__IP_ADDR_IP = 15,
+  CMSG_PROTO_BUF_HEADER__IP_ADDR_IP_V6 = 29
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(CMSG_PROTO_BUF_HEADER__IP_ADDR__CASE)
+} CMsgProtoBufHeader__IpAddrCase;
+
+struct CMsgProtoBufHeader : public ProtobufCppMessage
+{
+  CMsgProtoBufHeader() :
+     ProtobufCppMessage(cmsg_proto_buf_header__descriptor)
+  {}
+
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  protobuf_c_boolean has_client_sessionid;
+  int32_t client_sessionid;
+  protobuf_c_boolean has_routing_appid;
+  uint32_t routing_appid;
+  protobuf_c_boolean has_jobid_source;
+  uint64_t jobid_source;
+  protobuf_c_boolean has_jobid_target;
+  uint64_t jobid_target;
+  char *target_job_name;
+  protobuf_c_boolean has_seq_num;
+  int32_t seq_num;
+  protobuf_c_boolean has_eresult;
+  int32_t eresult;
+  char *error_message;
+  protobuf_c_boolean has_auth_account_flags;
+  uint32_t auth_account_flags;
+  protobuf_c_boolean has_token_source;
+  uint32_t token_source;
+  protobuf_c_boolean has_admin_spoofing_user;
+  protobuf_c_boolean admin_spoofing_user;
+  protobuf_c_boolean has_transport_error;
+  int32_t transport_error;
+  protobuf_c_boolean has_messageid;
+  uint64_t messageid;
+  protobuf_c_boolean has_publisher_group_id;
+  uint32_t publisher_group_id;
+  protobuf_c_boolean has_sysid;
+  uint32_t sysid;
+  protobuf_c_boolean has_trace_tag;
+  uint64_t trace_tag;
+  protobuf_c_boolean has_webapi_key_id;
+  uint32_t webapi_key_id;
+  protobuf_c_boolean has_is_from_external_source;
+  protobuf_c_boolean is_from_external_source;
+  size_t n_forward_to_sysid;
+  uint32_t *forward_to_sysid;
+  protobuf_c_boolean has_cm_sysid;
+  uint32_t cm_sysid;
+  protobuf_c_boolean has_launcher_type;
+  uint32_t launcher_type;
+  protobuf_c_boolean has_realm;
+  uint32_t realm;
+  protobuf_c_boolean has_timeout_ms;
+  int32_t timeout_ms;
+  char *debug_source;
+  protobuf_c_boolean has_debug_source_string_index;
+  uint32_t debug_source_string_index;
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+  CMsgGCRoutingProtoBufHeader *routing_gc;
+  CMsgProtoBufHeader__IpAddrCase ip_addr_case;
+  union {
+    uint32_t ip;
+    ProtobufCBinaryData ip_v6;
+  };
+};
+
+struct CMsgMulti : public ProtobufCppMessage
+{
+  CMsgMulti() :
+     ProtobufCppMessage(cmsg_multi__descriptor)
+  {}
+
+  protobuf_c_boolean has_size_unzipped;
+  uint32_t size_unzipped;
+  protobuf_c_boolean has_message_body;
+  ProtobufCBinaryData message_body;
+};
+
+struct CMsgProtobufWrapped : public ProtobufCppMessage
+{
+  CMsgProtobufWrapped() :
+     ProtobufCppMessage(cmsg_protobuf_wrapped__descriptor)
+  {}
+
+  protobuf_c_boolean has_message_body;
+  ProtobufCBinaryData message_body;
+};
+
+struct CMsgAuthTicket : public ProtobufCppMessage
+{
+  CMsgAuthTicket() :
+     ProtobufCppMessage(cmsg_auth_ticket__descriptor)
+  {}
+
+  protobuf_c_boolean has_estate;
+  uint32_t estate;
+  protobuf_c_boolean has_eresult;
+  uint32_t eresult;
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+  protobuf_c_boolean has_gameid;
+  uint64_t gameid;
+  protobuf_c_boolean has_h_steam_pipe;
+  uint32_t h_steam_pipe;
+  protobuf_c_boolean has_ticket_crc;
+  uint32_t ticket_crc;
+  protobuf_c_boolean has_ticket;
+  ProtobufCBinaryData ticket;
+  protobuf_c_boolean has_server_secret;
+  ProtobufCBinaryData server_secret;
+};
+
+struct CCDDBAppDetailCommon : public ProtobufCppMessage
+{
+  CCDDBAppDetailCommon() :
+     ProtobufCppMessage(ccddbapp_detail_common__descriptor)
+  {}
+
+  protobuf_c_boolean has_appid;
+  uint32_t appid;
+  char *name;
+  char *icon;
+  protobuf_c_boolean has_tool;
+  protobuf_c_boolean tool;
+  protobuf_c_boolean has_demo;
+  protobuf_c_boolean demo;
+  protobuf_c_boolean has_media;
+  protobuf_c_boolean media;
+  protobuf_c_boolean has_community_visible_stats;
+  protobuf_c_boolean community_visible_stats;
+  char *friendly_name;
+  char *propagation;
+  protobuf_c_boolean has_has_adult_content;
+  protobuf_c_boolean has_adult_content;
+  protobuf_c_boolean has_is_visible_in_steam_china;
+  protobuf_c_boolean is_visible_in_steam_china;
+  protobuf_c_boolean has_app_type;
+  uint32_t app_type;
+  protobuf_c_boolean has_has_adult_content_sex;
+  protobuf_c_boolean has_adult_content_sex;
+  protobuf_c_boolean has_has_adult_content_violence;
+  protobuf_c_boolean has_adult_content_violence;
+  size_t n_content_descriptorids;
+  uint32_t *content_descriptorids;
+};
+
+struct CMsgAppRights : public ProtobufCppMessage
+{
+  CMsgAppRights() :
+     ProtobufCppMessage(cmsg_app_rights__descriptor)
+  {}
+
+  protobuf_c_boolean has_edit_info;
+  protobuf_c_boolean edit_info;
+  protobuf_c_boolean has_publish;
+  protobuf_c_boolean publish;
+  protobuf_c_boolean has_view_error_data;
+  protobuf_c_boolean view_error_data;
+  protobuf_c_boolean has_download;
+  protobuf_c_boolean download;
+  protobuf_c_boolean has_upload_cdkeys;
+  protobuf_c_boolean upload_cdkeys;
+  protobuf_c_boolean has_generate_cdkeys;
+  protobuf_c_boolean generate_cdkeys;
+  protobuf_c_boolean has_view_financials;
+  protobuf_c_boolean view_financials;
+  protobuf_c_boolean has_manage_ceg;
+  protobuf_c_boolean manage_ceg;
+  protobuf_c_boolean has_manage_signing;
+  protobuf_c_boolean manage_signing;
+  protobuf_c_boolean has_manage_cdkeys;
+  protobuf_c_boolean manage_cdkeys;
+  protobuf_c_boolean has_edit_marketing;
+  protobuf_c_boolean edit_marketing;
+  protobuf_c_boolean has_economy_support;
+  protobuf_c_boolean economy_support;
+  protobuf_c_boolean has_economy_support_supervisor;
+  protobuf_c_boolean economy_support_supervisor;
+  protobuf_c_boolean has_manage_pricing;
+  protobuf_c_boolean manage_pricing;
+  protobuf_c_boolean has_broadcast_live;
+  protobuf_c_boolean broadcast_live;
+  protobuf_c_boolean has_view_marketing_traffic;
+  protobuf_c_boolean view_marketing_traffic;
+  protobuf_c_boolean has_edit_store_display_content;
+  protobuf_c_boolean edit_store_display_content;
+};
+
+struct CCuratorPreferences : public ProtobufCppMessage
+{
+  CCuratorPreferences() :
+     ProtobufCppMessage(ccurator_preferences__descriptor)
+  {}
+
+  protobuf_c_boolean has_supported_languages;
+  uint32_t supported_languages;
+  protobuf_c_boolean has_platform_windows;
+  protobuf_c_boolean platform_windows;
+  protobuf_c_boolean has_platform_mac;
+  protobuf_c_boolean platform_mac;
+  protobuf_c_boolean has_platform_linux;
+  protobuf_c_boolean platform_linux;
+  protobuf_c_boolean has_vr_content;
+  protobuf_c_boolean vr_content;
+  protobuf_c_boolean has_adult_content_violence;
+  protobuf_c_boolean adult_content_violence;
+  protobuf_c_boolean has_adult_content_sex;
+  protobuf_c_boolean adult_content_sex;
+  protobuf_c_boolean has_timestamp_updated;
+  uint32_t timestamp_updated;
+  size_t n_tagids_curated;
+  uint32_t *tagids_curated;
+  size_t n_tagids_filtered;
+  uint32_t *tagids_filtered;
+  char *website_title;
+  char *website_url;
+  char *discussion_url;
+  protobuf_c_boolean has_show_broadcast;
+  protobuf_c_boolean show_broadcast;
+};
+
+struct CLocalizationToken : public ProtobufCppMessage
+{
+  CLocalizationToken() :
+     ProtobufCppMessage(clocalization_token__descriptor)
+  {}
+
+  protobuf_c_boolean has_language;
+  uint32_t language;
+  char *localized_string;
+};
+
+struct CClanEventUserNewsTuple : public ProtobufCppMessage
+{
+  CClanEventUserNewsTuple() :
+     ProtobufCppMessage(cclan_event_user_news_tuple__descriptor)
+  {}
+
+  protobuf_c_boolean has_clanid;
+  uint32_t clanid;
+  protobuf_c_boolean has_event_gid;
+  uint64_t event_gid;
+  protobuf_c_boolean has_announcement_gid;
+  uint64_t announcement_gid;
+  protobuf_c_boolean has_rtime_start;
+  uint32_t rtime_start;
+  protobuf_c_boolean has_rtime_end;
+  uint32_t rtime_end;
+  protobuf_c_boolean has_priority_score;
+  uint32_t priority_score;
+  protobuf_c_boolean has_type;
+  uint32_t type;
+  protobuf_c_boolean has_clamp_range_slot;
+  uint32_t clamp_range_slot;
+  protobuf_c_boolean has_appid;
+  uint32_t appid;
+  protobuf_c_boolean has_rtime32_last_modified;
+  uint32_t rtime32_last_modified;
+};
+
+struct CClanMatchEventByRange : public ProtobufCppMessage
+{
+  CClanMatchEventByRange() :
+     ProtobufCppMessage(cclan_match_event_by_range__descriptor)
+  {}
+
+  protobuf_c_boolean has_rtime_before;
+  uint32_t rtime_before;
+  protobuf_c_boolean has_rtime_after;
+  uint32_t rtime_after;
+  protobuf_c_boolean has_qualified;
+  uint32_t qualified;
+  size_t n_events;
+  CClanEventUserNewsTuple **events;
+};
+
+struct CCommunityClanAnnouncementInfo : public ProtobufCppMessage
+{
+  CCommunityClanAnnouncementInfo() :
+     ProtobufCppMessage(ccommunity__clan_announcement_info__descriptor)
+  {}
+
+  protobuf_c_boolean has_gid;
+  uint64_t gid;
+  protobuf_c_boolean has_clanid;
+  uint64_t clanid;
+  protobuf_c_boolean has_posterid;
+  uint64_t posterid;
+  char *headline;
+  protobuf_c_boolean has_posttime;
+  uint32_t posttime;
+  protobuf_c_boolean has_updatetime;
+  uint32_t updatetime;
+  char *body;
+  protobuf_c_boolean has_commentcount;
+  int32_t commentcount;
+  size_t n_tags;
+  char **tags;
+  protobuf_c_boolean has_language;
+  int32_t language;
+  protobuf_c_boolean has_hidden;
+  protobuf_c_boolean hidden;
+  protobuf_c_boolean has_forum_topic_id;
+  uint64_t forum_topic_id;
+  protobuf_c_boolean has_event_gid;
+  uint64_t event_gid;
+  protobuf_c_boolean has_voteupcount;
+  int32_t voteupcount;
+  protobuf_c_boolean has_votedowncount;
+  int32_t votedowncount;
+  protobuf_c_boolean has_ban_check_result;
+  EBanContentCheckResult ban_check_result;
+  protobuf_c_boolean has_banned;
+  protobuf_c_boolean banned;
+};
+
+struct CClanEventData : public ProtobufCppMessage
+{
+  CClanEventData() :
+     ProtobufCppMessage(cclan_event_data__descriptor)
+  {}
+
+  protobuf_c_boolean has_gid;
+  uint64_t gid;
+  protobuf_c_boolean has_clan_steamid;
+  uint64_t clan_steamid;
+  char *event_name;
+  protobuf_c_boolean has_event_type;
+  EProtoClanEventType event_type;
+  protobuf_c_boolean has_appid;
+  uint32_t appid;
+  char *server_address;
+  char *server_password;
+  protobuf_c_boolean has_rtime32_start_time;
+  uint32_t rtime32_start_time;
+  protobuf_c_boolean has_rtime32_end_time;
+  uint32_t rtime32_end_time;
+  protobuf_c_boolean has_comment_count;
+  int32_t comment_count;
+  protobuf_c_boolean has_creator_steamid;
+  uint64_t creator_steamid;
+  protobuf_c_boolean has_last_update_steamid;
+  uint64_t last_update_steamid;
+  char *event_notes;
+  char *jsondata;
+  CCommunityClanAnnouncementInfo *announcement_body;
+  protobuf_c_boolean has_published;
+  protobuf_c_boolean published;
+  protobuf_c_boolean has_hidden;
+  protobuf_c_boolean hidden;
+  protobuf_c_boolean has_rtime32_visibility_start;
+  uint32_t rtime32_visibility_start;
+  protobuf_c_boolean has_rtime32_visibility_end;
+  uint32_t rtime32_visibility_end;
+  protobuf_c_boolean has_broadcaster_accountid;
+  uint32_t broadcaster_accountid;
+  protobuf_c_boolean has_follower_count;
+  uint32_t follower_count;
+  protobuf_c_boolean has_ignore_count;
+  uint32_t ignore_count;
+  protobuf_c_boolean has_forum_topic_id;
+  uint64_t forum_topic_id;
+  protobuf_c_boolean has_rtime32_last_modified;
+  uint32_t rtime32_last_modified;
+  protobuf_c_boolean has_news_post_gid;
+  uint64_t news_post_gid;
+  protobuf_c_boolean has_rtime_mod_reviewed;
+  uint32_t rtime_mod_reviewed;
+  protobuf_c_boolean has_featured_app_tagid;
+  uint32_t featured_app_tagid;
+  size_t n_referenced_appids;
+  uint32_t *referenced_appids;
+  protobuf_c_boolean has_build_id;
+  uint32_t build_id;
+  char *build_branch;
+};
+
+struct CBillingAddress : public ProtobufCppMessage
+{
+  CBillingAddress() :
+     ProtobufCppMessage(cbilling__address__descriptor)
+  {}
+
+  char *first_name;
+  char *last_name;
+  char *address1;
+  char *address2;
+  char *city;
+  char *us_state;
+  char *country_code;
+  char *postcode;
+  protobuf_c_boolean has_zip_plus4;
+  int32_t zip_plus4;
+  char *phone;
+};
+
+struct CPackageReservationStatus : public ProtobufCppMessage
+{
+  CPackageReservationStatus() :
+     ProtobufCppMessage(cpackage_reservation_status__descriptor)
+  {}
+
+  protobuf_c_boolean has_packageid;
+  uint32_t packageid;
+  protobuf_c_boolean has_reservation_state;
+  int32_t reservation_state;
+  protobuf_c_boolean has_queue_position;
+  int32_t queue_position;
+  protobuf_c_boolean has_total_queue_size;
+  int32_t total_queue_size;
+  char *reservation_country_code;
+  protobuf_c_boolean has_expired;
+  protobuf_c_boolean expired;
+  protobuf_c_boolean has_time_expires;
+  uint32_t time_expires;
+  protobuf_c_boolean has_time_reserved;
+  uint32_t time_reserved;
+};
+
+struct CMsgKeyValuePair : public ProtobufCppMessage
+{
+  CMsgKeyValuePair() :
+     ProtobufCppMessage(cmsg_key_value_pair__descriptor)
+  {}
+
+  char *name;
+  char *value;
+};
+
+struct CMsgKeyValueSet : public ProtobufCppMessage
+{
+  CMsgKeyValueSet() :
+     ProtobufCppMessage(cmsg_key_value_set__descriptor)
+  {}
+
+  size_t n_pairs;
+  CMsgKeyValuePair **pairs;
+};
+
+size_t cmsg_ipaddress__get_packed_size
+                     (const CMsgIPAddress   *message);
+size_t cmsg_ipaddress__pack
+                     (const CMsgIPAddress   *message,
+                      uint8_t             *out);
+size_t cmsg_ipaddress__pack_to_buffer
+                     (const CMsgIPAddress   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgIPAddress *
+       cmsg_ipaddress__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_ipaddress__free_unpacked
+                     (CMsgIPAddress *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_ipaddress_bucket__get_packed_size
+                     (const CMsgIPAddressBucket   *message);
+size_t cmsg_ipaddress_bucket__pack
+                     (const CMsgIPAddressBucket   *message,
+                      uint8_t             *out);
+size_t cmsg_ipaddress_bucket__pack_to_buffer
+                     (const CMsgIPAddressBucket   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgIPAddressBucket *
+       cmsg_ipaddress_bucket__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_ipaddress_bucket__free_unpacked
+                     (CMsgIPAddressBucket *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_gcrouting_proto_buf_header__get_packed_size
+                     (const CMsgGCRoutingProtoBufHeader   *message);
+size_t cmsg_gcrouting_proto_buf_header__pack
+                     (const CMsgGCRoutingProtoBufHeader   *message,
+                      uint8_t             *out);
+size_t cmsg_gcrouting_proto_buf_header__pack_to_buffer
+                     (const CMsgGCRoutingProtoBufHeader   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgGCRoutingProtoBufHeader *
+       cmsg_gcrouting_proto_buf_header__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_gcrouting_proto_buf_header__free_unpacked
+                     (CMsgGCRoutingProtoBufHeader *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_proto_buf_header__get_packed_size
+                     (const CMsgProtoBufHeader   *message);
+size_t cmsg_proto_buf_header__pack
+                     (const CMsgProtoBufHeader   *message,
+                      uint8_t             *out);
+size_t cmsg_proto_buf_header__pack_to_buffer
+                     (const CMsgProtoBufHeader   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgProtoBufHeader *
+       cmsg_proto_buf_header__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_proto_buf_header__free_unpacked
+                     (CMsgProtoBufHeader *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_multi__get_packed_size
+                     (const CMsgMulti   *message);
+size_t cmsg_multi__pack
+                     (const CMsgMulti   *message,
+                      uint8_t             *out);
+size_t cmsg_multi__pack_to_buffer
+                     (const CMsgMulti   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgMulti *
+       cmsg_multi__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_multi__free_unpacked
+                     (CMsgMulti *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_protobuf_wrapped__get_packed_size
+                     (const CMsgProtobufWrapped   *message);
+size_t cmsg_protobuf_wrapped__pack
+                     (const CMsgProtobufWrapped   *message,
+                      uint8_t             *out);
+size_t cmsg_protobuf_wrapped__pack_to_buffer
+                     (const CMsgProtobufWrapped   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgProtobufWrapped *
+       cmsg_protobuf_wrapped__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_protobuf_wrapped__free_unpacked
+                     (CMsgProtobufWrapped *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_auth_ticket__get_packed_size
+                     (const CMsgAuthTicket   *message);
+size_t cmsg_auth_ticket__pack
+                     (const CMsgAuthTicket   *message,
+                      uint8_t             *out);
+size_t cmsg_auth_ticket__pack_to_buffer
+                     (const CMsgAuthTicket   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgAuthTicket *
+       cmsg_auth_ticket__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_auth_ticket__free_unpacked
+                     (CMsgAuthTicket *message,
+                      ProtobufCAllocator *allocator);
+size_t ccddbapp_detail_common__get_packed_size
+                     (const CCDDBAppDetailCommon   *message);
+size_t ccddbapp_detail_common__pack
+                     (const CCDDBAppDetailCommon   *message,
+                      uint8_t             *out);
+size_t ccddbapp_detail_common__pack_to_buffer
+                     (const CCDDBAppDetailCommon   *message,
+                      ProtobufCBuffer     *buffer);
+CCDDBAppDetailCommon *
+       ccddbapp_detail_common__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccddbapp_detail_common__free_unpacked
+                     (CCDDBAppDetailCommon *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_app_rights__get_packed_size
+                     (const CMsgAppRights   *message);
+size_t cmsg_app_rights__pack
+                     (const CMsgAppRights   *message,
+                      uint8_t             *out);
+size_t cmsg_app_rights__pack_to_buffer
+                     (const CMsgAppRights   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgAppRights *
+       cmsg_app_rights__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_app_rights__free_unpacked
+                     (CMsgAppRights *message,
+                      ProtobufCAllocator *allocator);
+size_t ccurator_preferences__get_packed_size
+                     (const CCuratorPreferences   *message);
+size_t ccurator_preferences__pack
+                     (const CCuratorPreferences   *message,
+                      uint8_t             *out);
+size_t ccurator_preferences__pack_to_buffer
+                     (const CCuratorPreferences   *message,
+                      ProtobufCBuffer     *buffer);
+CCuratorPreferences *
+       ccurator_preferences__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccurator_preferences__free_unpacked
+                     (CCuratorPreferences *message,
+                      ProtobufCAllocator *allocator);
+size_t clocalization_token__get_packed_size
+                     (const CLocalizationToken   *message);
+size_t clocalization_token__pack
+                     (const CLocalizationToken   *message,
+                      uint8_t             *out);
+size_t clocalization_token__pack_to_buffer
+                     (const CLocalizationToken   *message,
+                      ProtobufCBuffer     *buffer);
+CLocalizationToken *
+       clocalization_token__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   clocalization_token__free_unpacked
+                     (CLocalizationToken *message,
+                      ProtobufCAllocator *allocator);
+size_t cclan_event_user_news_tuple__get_packed_size
+                     (const CClanEventUserNewsTuple   *message);
+size_t cclan_event_user_news_tuple__pack
+                     (const CClanEventUserNewsTuple   *message,
+                      uint8_t             *out);
+size_t cclan_event_user_news_tuple__pack_to_buffer
+                     (const CClanEventUserNewsTuple   *message,
+                      ProtobufCBuffer     *buffer);
+CClanEventUserNewsTuple *
+       cclan_event_user_news_tuple__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cclan_event_user_news_tuple__free_unpacked
+                     (CClanEventUserNewsTuple *message,
+                      ProtobufCAllocator *allocator);
+size_t cclan_match_event_by_range__get_packed_size
+                     (const CClanMatchEventByRange   *message);
+size_t cclan_match_event_by_range__pack
+                     (const CClanMatchEventByRange   *message,
+                      uint8_t             *out);
+size_t cclan_match_event_by_range__pack_to_buffer
+                     (const CClanMatchEventByRange   *message,
+                      ProtobufCBuffer     *buffer);
+CClanMatchEventByRange *
+       cclan_match_event_by_range__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cclan_match_event_by_range__free_unpacked
+                     (CClanMatchEventByRange *message,
+                      ProtobufCAllocator *allocator);
+size_t ccommunity__clan_announcement_info__get_packed_size
+                     (const CCommunityClanAnnouncementInfo   *message);
+size_t ccommunity__clan_announcement_info__pack
+                     (const CCommunityClanAnnouncementInfo   *message,
+                      uint8_t             *out);
+size_t ccommunity__clan_announcement_info__pack_to_buffer
+                     (const CCommunityClanAnnouncementInfo   *message,
+                      ProtobufCBuffer     *buffer);
+CCommunityClanAnnouncementInfo *
+       ccommunity__clan_announcement_info__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ccommunity__clan_announcement_info__free_unpacked
+                     (CCommunityClanAnnouncementInfo *message,
+                      ProtobufCAllocator *allocator);
+size_t cclan_event_data__get_packed_size
+                     (const CClanEventData   *message);
+size_t cclan_event_data__pack
+                     (const CClanEventData   *message,
+                      uint8_t             *out);
+size_t cclan_event_data__pack_to_buffer
+                     (const CClanEventData   *message,
+                      ProtobufCBuffer     *buffer);
+CClanEventData *
+       cclan_event_data__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cclan_event_data__free_unpacked
+                     (CClanEventData *message,
+                      ProtobufCAllocator *allocator);
+size_t cbilling__address__get_packed_size
+                     (const CBillingAddress   *message);
+size_t cbilling__address__pack
+                     (const CBillingAddress   *message,
+                      uint8_t             *out);
+size_t cbilling__address__pack_to_buffer
+                     (const CBillingAddress   *message,
+                      ProtobufCBuffer     *buffer);
+CBillingAddress *
+       cbilling__address__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cbilling__address__free_unpacked
+                     (CBillingAddress *message,
+                      ProtobufCAllocator *allocator);
+size_t cpackage_reservation_status__get_packed_size
+                     (const CPackageReservationStatus   *message);
+size_t cpackage_reservation_status__pack
+                     (const CPackageReservationStatus   *message,
+                      uint8_t             *out);
+size_t cpackage_reservation_status__pack_to_buffer
+                     (const CPackageReservationStatus   *message,
+                      ProtobufCBuffer     *buffer);
+CPackageReservationStatus *
+       cpackage_reservation_status__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cpackage_reservation_status__free_unpacked
+                     (CPackageReservationStatus *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_key_value_pair__get_packed_size
+                     (const CMsgKeyValuePair   *message);
+size_t cmsg_key_value_pair__pack
+                     (const CMsgKeyValuePair   *message,
+                      uint8_t             *out);
+size_t cmsg_key_value_pair__pack_to_buffer
+                     (const CMsgKeyValuePair   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgKeyValuePair *
+       cmsg_key_value_pair__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_key_value_pair__free_unpacked
+                     (CMsgKeyValuePair *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_key_value_set__get_packed_size
+                     (const CMsgKeyValueSet   *message);
+size_t cmsg_key_value_set__pack
+                     (const CMsgKeyValueSet   *message,
+                      uint8_t             *out);
+size_t cmsg_key_value_set__pack_to_buffer
+                     (const CMsgKeyValueSet   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgKeyValueSet *
+       cmsg_key_value_set__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_key_value_set__free_unpacked
+                     (CMsgKeyValueSet *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*CMsgIPAddress_Closure)
+                 (const CMsgIPAddress *message,
+                  void *closure_data);
+typedef void (*CMsgIPAddressBucket_Closure)
+                 (const CMsgIPAddressBucket *message,
+                  void *closure_data);
+typedef void (*CMsgGCRoutingProtoBufHeader_Closure)
+                 (const CMsgGCRoutingProtoBufHeader *message,
+                  void *closure_data);
+typedef void (*CMsgProtoBufHeader_Closure)
+                 (const CMsgProtoBufHeader *message,
+                  void *closure_data);
+typedef void (*CMsgMulti_Closure)
+                 (const CMsgMulti *message,
+                  void *closure_data);
+typedef void (*CMsgProtobufWrapped_Closure)
+                 (const CMsgProtobufWrapped *message,
+                  void *closure_data);
+typedef void (*CMsgAuthTicket_Closure)
+                 (const CMsgAuthTicket *message,
+                  void *closure_data);
+typedef void (*CCDDBAppDetailCommon_Closure)
+                 (const CCDDBAppDetailCommon *message,
+                  void *closure_data);
+typedef void (*CMsgAppRights_Closure)
+                 (const CMsgAppRights *message,
+                  void *closure_data);
+typedef void (*CCuratorPreferences_Closure)
+                 (const CCuratorPreferences *message,
+                  void *closure_data);
+typedef void (*CLocalizationToken_Closure)
+                 (const CLocalizationToken *message,
+                  void *closure_data);
+typedef void (*CClanEventUserNewsTuple_Closure)
+                 (const CClanEventUserNewsTuple *message,
+                  void *closure_data);
+typedef void (*CClanMatchEventByRange_Closure)
+                 (const CClanMatchEventByRange *message,
+                  void *closure_data);
+typedef void (*CCommunityClanAnnouncementInfo_Closure)
+                 (const CCommunityClanAnnouncementInfo *message,
+                  void *closure_data);
+typedef void (*CClanEventData_Closure)
+                 (const CClanEventData *message,
+                  void *closure_data);
+typedef void (*CBillingAddress_Closure)
+                 (const CBillingAddress *message,
+                  void *closure_data);
+typedef void (*CPackageReservationStatus_Closure)
+                 (const CPackageReservationStatus *message,
+                  void *closure_data);
+typedef void (*CMsgKeyValuePair_Closure)
+                 (const CMsgKeyValuePair *message,
+                  void *closure_data);
+typedef void (*CMsgKeyValueSet_Closure)
+                 (const CMsgKeyValueSet *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_steammessages_5fbase_2eproto__INCLUDED */
diff --git a/protocols/Steam/src/protobuf-c/steammessages_base.proto b/protocols/Steam/src/protobuf-c/steammessages_base.proto
new file mode 100644
index 0000000000..d64ce8acc3
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_base.proto
@@ -0,0 +1,314 @@
+import "google/protobuf/descriptor.proto";
+
+option optimize_for = SPEED;
+option cc_generic_services = true;
+option (force_php_generation) = true;
+
+extend .google.protobuf.MessageOptions {
+	optional int32 msgpool_soft_limit = 50000 [default = 32];
+	optional int32 msgpool_hard_limit = 50001 [default = 384];
+}
+
+extend .google.protobuf.FileOptions {
+	optional bool force_php_generation = 50000 [default = false];
+}
+
+extend .google.protobuf.FieldOptions {
+	optional bool php_output_always_number = 50020 [default = false];
+	optional bool allow_field_named_steam_id = 50024 [default = false];
+}
+
+enum EBanContentCheckResult {
+	k_EBanContentCheckResult_NotScanned = 0;
+	k_EBanContentCheckResult_Reset = 1;
+	k_EBanContentCheckResult_NeedsChecking = 2;
+	k_EBanContentCheckResult_VeryUnlikely = 5;
+	k_EBanContentCheckResult_Unlikely = 30;
+	k_EBanContentCheckResult_Possible = 50;
+	k_EBanContentCheckResult_Likely = 75;
+	k_EBanContentCheckResult_VeryLikely = 100;
+}
+
+enum EProtoClanEventType {
+	k_EClanOtherEvent = 1;
+	k_EClanGameEvent = 2;
+	k_EClanPartyEvent = 3;
+	k_EClanMeetingEvent = 4;
+	k_EClanSpecialCauseEvent = 5;
+	k_EClanMusicAndArtsEvent = 6;
+	k_EClanSportsEvent = 7;
+	k_EClanTripEvent = 8;
+	k_EClanChatEvent = 9;
+	k_EClanGameReleaseEvent = 10;
+	k_EClanBroadcastEvent = 11;
+	k_EClanSmallUpdateEvent = 12;
+	k_EClanPreAnnounceMajorUpdateEvent = 13;
+	k_EClanMajorUpdateEvent = 14;
+	k_EClanDLCReleaseEvent = 15;
+	k_EClanFutureReleaseEvent = 16;
+	k_EClanESportTournamentStreamEvent = 17;
+	k_EClanDevStreamEvent = 18;
+	k_EClanFamousStreamEvent = 19;
+	k_EClanGameSalesEvent = 20;
+	k_EClanGameItemSalesEvent = 21;
+	k_EClanInGameBonusXPEvent = 22;
+	k_EClanInGameLootEvent = 23;
+	k_EClanInGamePerksEvent = 24;
+	k_EClanInGameChallengeEvent = 25;
+	k_EClanInGameContestEvent = 26;
+	k_EClanIRLEvent = 27;
+	k_EClanNewsEvent = 28;
+	k_EClanBetaReleaseEvent = 29;
+	k_EClanInGameContentReleaseEvent = 30;
+	k_EClanFreeTrial = 31;
+	k_EClanSeasonRelease = 32;
+	k_EClanSeasonUpdate = 33;
+	k_EClanCrosspostEvent = 34;
+	k_EClanInGameEventGeneral = 35;
+}
+
+enum PartnerEventNotificationType {
+	k_EEventStart = 0;
+	k_EEventBroadcastStart = 1;
+	k_EEventMatchStart = 2;
+	k_EEventPartnerMaxType = 3;
+}
+
+message CMsgIPAddress {
+	oneof ip {
+		fixed32 v4 = 1;
+		bytes v6 = 2;
+	}
+}
+
+message CMsgIPAddressBucket {
+	optional .CMsgIPAddress original_ip_address = 1;
+	optional fixed64 bucket = 2;
+}
+
+message CMsgGCRoutingProtoBufHeader {
+	optional uint64 dst_gcid_queue = 1;
+	optional uint32 dst_gc_dir_index = 2;
+}
+
+message CMsgProtoBufHeader {
+	optional fixed64 steamid = 1;
+	optional int32 client_sessionid = 2;
+	optional uint32 routing_appid = 3;
+	optional fixed64 jobid_source = 10 [default = 18446744073709551615];
+	optional fixed64 jobid_target = 11 [default = 18446744073709551615];
+	optional string target_job_name = 12;
+	optional int32 seq_num = 24;
+	optional int32 eresult = 13 [default = 2];
+	optional string error_message = 14;
+	optional uint32 auth_account_flags = 16;
+	optional uint32 token_source = 22;
+	optional bool admin_spoofing_user = 23;
+	optional int32 transport_error = 17 [default = 1];
+	optional uint64 messageid = 18 [default = 18446744073709551615];
+	optional uint32 publisher_group_id = 19;
+	optional uint32 sysid = 20;
+	optional uint64 trace_tag = 21;
+	optional uint32 webapi_key_id = 25;
+	optional bool is_from_external_source = 26;
+	repeated uint32 forward_to_sysid = 27;
+	optional uint32 cm_sysid = 28;
+	optional uint32 launcher_type = 31 [default = 0];
+	optional uint32 realm = 32 [default = 0];
+	optional int32 timeout_ms = 33 [default = -1];
+	optional string debug_source = 34;
+	optional uint32 debug_source_string_index = 35;
+	optional uint64 token_id = 36;
+	optional .CMsgGCRoutingProtoBufHeader routing_gc = 37;
+
+	oneof ip_addr {
+		uint32 ip = 15;
+		bytes ip_v6 = 29;
+	}
+}
+
+message CMsgMulti {
+	optional uint32 size_unzipped = 1;
+	optional bytes message_body = 2;
+}
+
+message CMsgProtobufWrapped {
+	optional bytes message_body = 1;
+}
+
+message CMsgAuthTicket {
+	optional uint32 estate = 1;
+	optional uint32 eresult = 2 [default = 2];
+	optional fixed64 steamid = 3;
+	optional fixed64 gameid = 4;
+	optional uint32 h_steam_pipe = 5;
+	optional uint32 ticket_crc = 6;
+	optional bytes ticket = 7;
+	optional bytes server_secret = 8;
+}
+
+message CCDDBAppDetailCommon {
+	optional uint32 appid = 1;
+	optional string name = 2;
+	optional string icon = 3;
+	optional bool tool = 6;
+	optional bool demo = 7;
+	optional bool media = 8;
+	optional bool community_visible_stats = 9;
+	optional string friendly_name = 10;
+	optional string propagation = 11;
+	optional bool has_adult_content = 12;
+	optional bool is_visible_in_steam_china = 13;
+	optional uint32 app_type = 14;
+	optional bool has_adult_content_sex = 15;
+	optional bool has_adult_content_violence = 16;
+	repeated uint32 content_descriptorids = 17;
+}
+
+message CMsgAppRights {
+	optional bool edit_info = 1;
+	optional bool publish = 2;
+	optional bool view_error_data = 3;
+	optional bool download = 4;
+	optional bool upload_cdkeys = 5;
+	optional bool generate_cdkeys = 6;
+	optional bool view_financials = 7;
+	optional bool manage_ceg = 8;
+	optional bool manage_signing = 9;
+	optional bool manage_cdkeys = 10;
+	optional bool edit_marketing = 11;
+	optional bool economy_support = 12;
+	optional bool economy_support_supervisor = 13;
+	optional bool manage_pricing = 14;
+	optional bool broadcast_live = 15;
+	optional bool view_marketing_traffic = 16;
+	optional bool edit_store_display_content = 17;
+}
+
+message CCuratorPreferences {
+	optional uint32 supported_languages = 1;
+	optional bool platform_windows = 2;
+	optional bool platform_mac = 3;
+	optional bool platform_linux = 4;
+	optional bool vr_content = 5;
+	optional bool adult_content_violence = 6;
+	optional bool adult_content_sex = 7;
+	optional uint32 timestamp_updated = 8;
+	repeated uint32 tagids_curated = 9;
+	repeated uint32 tagids_filtered = 10;
+	optional string website_title = 11;
+	optional string website_url = 12;
+	optional string discussion_url = 13;
+	optional bool show_broadcast = 14;
+}
+
+message CLocalizationToken {
+	optional uint32 language = 1;
+	optional string localized_string = 2;
+}
+
+message CClanEventUserNewsTuple {
+	optional uint32 clanid = 1;
+	optional fixed64 event_gid = 2;
+	optional fixed64 announcement_gid = 3;
+	optional uint32 rtime_start = 4;
+	optional uint32 rtime_end = 5;
+	optional uint32 priority_score = 6;
+	optional uint32 type = 7;
+	optional uint32 clamp_range_slot = 8;
+	optional uint32 appid = 9;
+	optional uint32 rtime32_last_modified = 10;
+}
+
+message CClanMatchEventByRange {
+	optional uint32 rtime_before = 1;
+	optional uint32 rtime_after = 2;
+	optional uint32 qualified = 3;
+	repeated .CClanEventUserNewsTuple events = 4;
+}
+
+message CCommunity_ClanAnnouncementInfo {
+	optional uint64 gid = 1;
+	optional uint64 clanid = 2;
+	optional uint64 posterid = 3;
+	optional string headline = 4;
+	optional uint32 posttime = 5;
+	optional uint32 updatetime = 6;
+	optional string body = 7;
+	optional int32 commentcount = 8;
+	repeated string tags = 9;
+	optional int32 language = 10;
+	optional bool hidden = 11;
+	optional fixed64 forum_topic_id = 12;
+	optional fixed64 event_gid = 13;
+	optional int32 voteupcount = 14;
+	optional int32 votedowncount = 15;
+	optional .EBanContentCheckResult ban_check_result = 16 [default = k_EBanContentCheckResult_NotScanned];
+	optional bool banned = 17;
+}
+
+message CClanEventData {
+	optional fixed64 gid = 1;
+	optional fixed64 clan_steamid = 2;
+	optional string event_name = 3;
+	optional .EProtoClanEventType event_type = 4 [default = k_EClanOtherEvent];
+	optional uint32 appid = 5;
+	optional string server_address = 6;
+	optional string server_password = 7;
+	optional uint32 rtime32_start_time = 8;
+	optional uint32 rtime32_end_time = 9;
+	optional int32 comment_count = 10;
+	optional fixed64 creator_steamid = 11;
+	optional fixed64 last_update_steamid = 12;
+	optional string event_notes = 13;
+	optional string jsondata = 14;
+	optional .CCommunity_ClanAnnouncementInfo announcement_body = 15;
+	optional bool published = 16;
+	optional bool hidden = 17;
+	optional uint32 rtime32_visibility_start = 18;
+	optional uint32 rtime32_visibility_end = 19;
+	optional uint32 broadcaster_accountid = 20;
+	optional uint32 follower_count = 21;
+	optional uint32 ignore_count = 22;
+	optional fixed64 forum_topic_id = 23;
+	optional uint32 rtime32_last_modified = 24;
+	optional fixed64 news_post_gid = 25;
+	optional uint32 rtime_mod_reviewed = 26;
+	optional uint32 featured_app_tagid = 27;
+	repeated uint32 referenced_appids = 28;
+	optional uint32 build_id = 29;
+	optional string build_branch = 30;
+}
+
+message CBilling_Address {
+	optional string first_name = 1;
+	optional string last_name = 2;
+	optional string address1 = 3;
+	optional string address2 = 4;
+	optional string city = 5;
+	optional string us_state = 6;
+	optional string country_code = 7;
+	optional string postcode = 8;
+	optional int32 zip_plus4 = 9;
+	optional string phone = 10;
+}
+
+message CPackageReservationStatus {
+	optional uint32 packageid = 1;
+	optional int32 reservation_state = 2;
+	optional int32 queue_position = 3;
+	optional int32 total_queue_size = 4;
+	optional string reservation_country_code = 5;
+	optional bool expired = 6;
+	optional uint32 time_expires = 7;
+	optional uint32 time_reserved = 8;
+}
+
+message CMsgKeyValuePair {
+	optional string name = 1;
+	optional string value = 2;
+}
+
+message CMsgKeyValueSet {
+	repeated .CMsgKeyValuePair pairs = 1;
+}
diff --git a/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.pb-c.cpp b/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.pb-c.cpp
new file mode 100644
index 0000000000..5910e4b262
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.pb-c.cpp
@@ -0,0 +1,2533 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_clientserver_login.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "steammessages_clientserver_login.pb-c.h"
+size_t cmsg_client_heart_beat__get_packed_size
+                     (const CMsgClientHeartBeat *message)
+{
+  assert(message->descriptor == &cmsg_client_heart_beat__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_heart_beat__pack
+                     (const CMsgClientHeartBeat *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_heart_beat__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_heart_beat__pack_to_buffer
+                     (const CMsgClientHeartBeat *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_heart_beat__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientHeartBeat *
+       cmsg_client_heart_beat__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientHeartBeat *)
+     protobuf_c_message_unpack (&cmsg_client_heart_beat__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_heart_beat__free_unpacked
+                     (CMsgClientHeartBeat *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_heart_beat__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_server_timestamp_request__get_packed_size
+                     (const CMsgClientServerTimestampRequest *message)
+{
+  assert(message->descriptor == &cmsg_client_server_timestamp_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_server_timestamp_request__pack
+                     (const CMsgClientServerTimestampRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_server_timestamp_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_server_timestamp_request__pack_to_buffer
+                     (const CMsgClientServerTimestampRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_server_timestamp_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientServerTimestampRequest *
+       cmsg_client_server_timestamp_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientServerTimestampRequest *)
+     protobuf_c_message_unpack (&cmsg_client_server_timestamp_request__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_server_timestamp_request__free_unpacked
+                     (CMsgClientServerTimestampRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_server_timestamp_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_server_timestamp_response__get_packed_size
+                     (const CMsgClientServerTimestampResponse *message)
+{
+  assert(message->descriptor == &cmsg_client_server_timestamp_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_server_timestamp_response__pack
+                     (const CMsgClientServerTimestampResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_server_timestamp_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_server_timestamp_response__pack_to_buffer
+                     (const CMsgClientServerTimestampResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_server_timestamp_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientServerTimestampResponse *
+       cmsg_client_server_timestamp_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientServerTimestampResponse *)
+     protobuf_c_message_unpack (&cmsg_client_server_timestamp_response__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_server_timestamp_response__free_unpacked
+                     (CMsgClientServerTimestampResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_server_timestamp_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_secret__get_packed_size
+                     (const CMsgClientSecret *message)
+{
+  assert(message->descriptor == &cmsg_client_secret__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_secret__pack
+                     (const CMsgClientSecret *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_secret__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_secret__pack_to_buffer
+                     (const CMsgClientSecret *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_secret__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientSecret *
+       cmsg_client_secret__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientSecret *)
+     protobuf_c_message_unpack (&cmsg_client_secret__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_secret__free_unpacked
+                     (CMsgClientSecret *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_secret__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_hello__get_packed_size
+                     (const CMsgClientHello *message)
+{
+  assert(message->descriptor == &cmsg_client_hello__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_hello__pack
+                     (const CMsgClientHello *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_hello__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_hello__pack_to_buffer
+                     (const CMsgClientHello *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_hello__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientHello *
+       cmsg_client_hello__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientHello *)
+     protobuf_c_message_unpack (&cmsg_client_hello__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_hello__free_unpacked
+                     (CMsgClientHello *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_hello__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_logon__get_packed_size
+                     (const CMsgClientLogon *message)
+{
+  assert(message->descriptor == &cmsg_client_logon__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_logon__pack
+                     (const CMsgClientLogon *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_logon__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_logon__pack_to_buffer
+                     (const CMsgClientLogon *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_logon__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientLogon *
+       cmsg_client_logon__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientLogon *)
+     protobuf_c_message_unpack (&cmsg_client_logon__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_logon__free_unpacked
+                     (CMsgClientLogon *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_logon__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_logon_response__get_packed_size
+                     (const CMsgClientLogonResponse *message)
+{
+  assert(message->descriptor == &cmsg_client_logon_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_logon_response__pack
+                     (const CMsgClientLogonResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_logon_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_logon_response__pack_to_buffer
+                     (const CMsgClientLogonResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_logon_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientLogonResponse *
+       cmsg_client_logon_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientLogonResponse *)
+     protobuf_c_message_unpack (&cmsg_client_logon_response__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_logon_response__free_unpacked
+                     (CMsgClientLogonResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_logon_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_request_web_apiauthenticate_user_nonce__get_packed_size
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonce *message)
+{
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_request_web_apiauthenticate_user_nonce__pack
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonce *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_request_web_apiauthenticate_user_nonce__pack_to_buffer
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonce *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientRequestWebAPIAuthenticateUserNonce *
+       cmsg_client_request_web_apiauthenticate_user_nonce__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientRequestWebAPIAuthenticateUserNonce *)
+     protobuf_c_message_unpack (&cmsg_client_request_web_apiauthenticate_user_nonce__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_request_web_apiauthenticate_user_nonce__free_unpacked
+                     (CMsgClientRequestWebAPIAuthenticateUserNonce *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_request_web_apiauthenticate_user_nonce_response__get_packed_size
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonceResponse *message)
+{
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_request_web_apiauthenticate_user_nonce_response__pack
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonceResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_request_web_apiauthenticate_user_nonce_response__pack_to_buffer
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonceResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientRequestWebAPIAuthenticateUserNonceResponse *
+       cmsg_client_request_web_apiauthenticate_user_nonce_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientRequestWebAPIAuthenticateUserNonceResponse *)
+     protobuf_c_message_unpack (&cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_request_web_apiauthenticate_user_nonce_response__free_unpacked
+                     (CMsgClientRequestWebAPIAuthenticateUserNonceResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_log_off__get_packed_size
+                     (const CMsgClientLogOff *message)
+{
+  assert(message->descriptor == &cmsg_client_log_off__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_log_off__pack
+                     (const CMsgClientLogOff *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_log_off__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_log_off__pack_to_buffer
+                     (const CMsgClientLogOff *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_log_off__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientLogOff *
+       cmsg_client_log_off__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientLogOff *)
+     protobuf_c_message_unpack (&cmsg_client_log_off__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_log_off__free_unpacked
+                     (CMsgClientLogOff *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_log_off__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_logged_off__get_packed_size
+                     (const CMsgClientLoggedOff *message)
+{
+  assert(message->descriptor == &cmsg_client_logged_off__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_logged_off__pack
+                     (const CMsgClientLoggedOff *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_logged_off__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_logged_off__pack_to_buffer
+                     (const CMsgClientLoggedOff *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_logged_off__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientLoggedOff *
+       cmsg_client_logged_off__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientLoggedOff *)
+     protobuf_c_message_unpack (&cmsg_client_logged_off__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_logged_off__free_unpacked
+                     (CMsgClientLoggedOff *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_logged_off__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_new_login_key__get_packed_size
+                     (const CMsgClientNewLoginKey *message)
+{
+  assert(message->descriptor == &cmsg_client_new_login_key__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_new_login_key__pack
+                     (const CMsgClientNewLoginKey *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_new_login_key__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_new_login_key__pack_to_buffer
+                     (const CMsgClientNewLoginKey *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_new_login_key__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientNewLoginKey *
+       cmsg_client_new_login_key__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientNewLoginKey *)
+     protobuf_c_message_unpack (&cmsg_client_new_login_key__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_new_login_key__free_unpacked
+                     (CMsgClientNewLoginKey *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_new_login_key__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_new_login_key_accepted__get_packed_size
+                     (const CMsgClientNewLoginKeyAccepted *message)
+{
+  assert(message->descriptor == &cmsg_client_new_login_key_accepted__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_new_login_key_accepted__pack
+                     (const CMsgClientNewLoginKeyAccepted *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_new_login_key_accepted__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_new_login_key_accepted__pack_to_buffer
+                     (const CMsgClientNewLoginKeyAccepted *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_new_login_key_accepted__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientNewLoginKeyAccepted *
+       cmsg_client_new_login_key_accepted__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientNewLoginKeyAccepted *)
+     protobuf_c_message_unpack (&cmsg_client_new_login_key_accepted__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_new_login_key_accepted__free_unpacked
+                     (CMsgClientNewLoginKeyAccepted *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_new_login_key_accepted__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_account_info__get_packed_size
+                     (const CMsgClientAccountInfo *message)
+{
+  assert(message->descriptor == &cmsg_client_account_info__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_account_info__pack
+                     (const CMsgClientAccountInfo *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_account_info__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_account_info__pack_to_buffer
+                     (const CMsgClientAccountInfo *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_account_info__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientAccountInfo *
+       cmsg_client_account_info__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientAccountInfo *)
+     protobuf_c_message_unpack (&cmsg_client_account_info__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_account_info__free_unpacked
+                     (CMsgClientAccountInfo *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_account_info__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_challenge_request__get_packed_size
+                     (const CMsgClientChallengeRequest *message)
+{
+  assert(message->descriptor == &cmsg_client_challenge_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_challenge_request__pack
+                     (const CMsgClientChallengeRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_challenge_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_challenge_request__pack_to_buffer
+                     (const CMsgClientChallengeRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_challenge_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientChallengeRequest *
+       cmsg_client_challenge_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientChallengeRequest *)
+     protobuf_c_message_unpack (&cmsg_client_challenge_request__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_challenge_request__free_unpacked
+                     (CMsgClientChallengeRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_challenge_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+size_t cmsg_client_challenge_response__get_packed_size
+                     (const CMsgClientChallengeResponse *message)
+{
+  assert(message->descriptor == &cmsg_client_challenge_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t cmsg_client_challenge_response__pack
+                     (const CMsgClientChallengeResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &cmsg_client_challenge_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t cmsg_client_challenge_response__pack_to_buffer
+                     (const CMsgClientChallengeResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &cmsg_client_challenge_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CMsgClientChallengeResponse *
+       cmsg_client_challenge_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CMsgClientChallengeResponse *)
+     protobuf_c_message_unpack (&cmsg_client_challenge_response__descriptor,
+                                allocator, len, data);
+}
+void   cmsg_client_challenge_response__free_unpacked
+                     (CMsgClientChallengeResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &cmsg_client_challenge_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+static const ProtobufCFieldDescriptor cmsg_client_heart_beat__field_descriptors[1] =
+{
+  {
+    "send_reply",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientHeartBeat, has_send_reply),
+    offsetof(CMsgClientHeartBeat, send_reply),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_heart_beat__field_indices_by_name[] = {
+  0,   /* field[0] = send_reply */
+};
+static const ProtobufCIntRange cmsg_client_heart_beat__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_heart_beat__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientHeartBeat",
+  "CMsgClientHeartBeat",
+  "CMsgClientHeartBeat",
+  "",
+  sizeof(CMsgClientHeartBeat),
+  1,
+  cmsg_client_heart_beat__field_descriptors,
+  cmsg_client_heart_beat__field_indices_by_name,
+  1,  cmsg_client_heart_beat__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_server_timestamp_request__field_descriptors[1] =
+{
+  {
+    "client_request_timestamp",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgClientServerTimestampRequest, has_client_request_timestamp),
+    offsetof(CMsgClientServerTimestampRequest, client_request_timestamp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_server_timestamp_request__field_indices_by_name[] = {
+  0,   /* field[0] = client_request_timestamp */
+};
+static const ProtobufCIntRange cmsg_client_server_timestamp_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_server_timestamp_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientServerTimestampRequest",
+  "CMsgClientServerTimestampRequest",
+  "CMsgClientServerTimestampRequest",
+  "",
+  sizeof(CMsgClientServerTimestampRequest),
+  1,
+  cmsg_client_server_timestamp_request__field_descriptors,
+  cmsg_client_server_timestamp_request__field_indices_by_name,
+  1,  cmsg_client_server_timestamp_request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_server_timestamp_response__field_descriptors[2] =
+{
+  {
+    "client_request_timestamp",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgClientServerTimestampResponse, has_client_request_timestamp),
+    offsetof(CMsgClientServerTimestampResponse, client_request_timestamp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "server_timestamp_ms",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgClientServerTimestampResponse, has_server_timestamp_ms),
+    offsetof(CMsgClientServerTimestampResponse, server_timestamp_ms),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_server_timestamp_response__field_indices_by_name[] = {
+  0,   /* field[0] = client_request_timestamp */
+  1,   /* field[1] = server_timestamp_ms */
+};
+static const ProtobufCIntRange cmsg_client_server_timestamp_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cmsg_client_server_timestamp_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientServerTimestampResponse",
+  "CMsgClientServerTimestampResponse",
+  "CMsgClientServerTimestampResponse",
+  "",
+  sizeof(CMsgClientServerTimestampResponse),
+  2,
+  cmsg_client_server_timestamp_response__field_descriptors,
+  cmsg_client_server_timestamp_response__field_indices_by_name,
+  1,  cmsg_client_server_timestamp_response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_secret__field_descriptors[5] =
+{
+  {
+    "version",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientSecret, has_version),
+    offsetof(CMsgClientSecret, version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "appid",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientSecret, has_appid),
+    offsetof(CMsgClientSecret, appid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "deviceid",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientSecret, has_deviceid),
+    offsetof(CMsgClientSecret, deviceid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "nonce",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgClientSecret, has_nonce),
+    offsetof(CMsgClientSecret, nonce),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "hmac",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientSecret, has_hmac),
+    offsetof(CMsgClientSecret, hmac),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_secret__field_indices_by_name[] = {
+  1,   /* field[1] = appid */
+  2,   /* field[2] = deviceid */
+  4,   /* field[4] = hmac */
+  3,   /* field[3] = nonce */
+  0,   /* field[0] = version */
+};
+static const ProtobufCIntRange cmsg_client_secret__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 5 }
+};
+const ProtobufCMessageDescriptor cmsg_client_secret__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientSecret",
+  "CMsgClientSecret",
+  "CMsgClientSecret",
+  "",
+  sizeof(CMsgClientSecret),
+  5,
+  cmsg_client_secret__field_descriptors,
+  cmsg_client_secret__field_indices_by_name,
+  1,  cmsg_client_secret__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_hello__field_descriptors[1] =
+{
+  {
+    "protocol_version",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientHello, has_protocol_version),
+    offsetof(CMsgClientHello, protocol_version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_hello__field_indices_by_name[] = {
+  0,   /* field[0] = protocol_version */
+};
+static const ProtobufCIntRange cmsg_client_hello__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_hello__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientHello",
+  "CMsgClientHello",
+  "CMsgClientHello",
+  "",
+  sizeof(CMsgClientHello),
+  1,
+  cmsg_client_hello__field_descriptors,
+  cmsg_client_hello__field_indices_by_name,
+  1,  cmsg_client_hello__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const protobuf_c_boolean cmsg_client_logon__should_remember_password__default_value = 0;
+static const uint32_t cmsg_client_logon__launcher_type__default_value = 0u;
+static const uint32_t cmsg_client_logon__ui_mode__default_value = 0u;
+static const uint32_t cmsg_client_logon__chat_mode__default_value = 0u;
+static const protobuf_c_boolean cmsg_client_logon__was_converted_deprecated_msg__default_value = 0;
+static const protobuf_c_boolean cmsg_client_logon__create_new_psn_linked_account_if_needed__default_value = 0;
+static const ProtobufCFieldDescriptor cmsg_client_logon__field_descriptors[57] =
+{
+  {
+    "protocol_version",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_protocol_version),
+    offsetof(CMsgClientLogon, protocol_version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "deprecated_obfustucated_private_ip",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_deprecated_obfustucated_private_ip),
+    offsetof(CMsgClientLogon, deprecated_obfustucated_private_ip),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "cell_id",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_cell_id),
+    offsetof(CMsgClientLogon, cell_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "last_session_id",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_last_session_id),
+    offsetof(CMsgClientLogon, last_session_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_package_version",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_client_package_version),
+    offsetof(CMsgClientLogon, client_package_version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_language",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, client_language),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_os_type",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_client_os_type),
+    offsetof(CMsgClientLogon, client_os_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "should_remember_password",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_should_remember_password),
+    offsetof(CMsgClientLogon, should_remember_password),
+    NULL,
+    &cmsg_client_logon__should_remember_password__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "wine_version",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, wine_version),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "deprecated_10",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_deprecated_10),
+    offsetof(CMsgClientLogon, deprecated_10),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "obfuscated_private_ip",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, obfuscated_private_ip),
+    &cmsg_ipaddress__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "deprecated_public_ip",
+    20,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_deprecated_public_ip),
+    offsetof(CMsgClientLogon, deprecated_public_ip),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "qos_level",
+    21,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_qos_level),
+    offsetof(CMsgClientLogon, qos_level),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_supplied_steam_id",
+    22,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgClientLogon, has_client_supplied_steam_id),
+    offsetof(CMsgClientLogon, client_supplied_steam_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "public_ip",
+    23,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, public_ip),
+    &cmsg_ipaddress__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "machine_id",
+    30,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientLogon, has_machine_id),
+    offsetof(CMsgClientLogon, machine_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "launcher_type",
+    31,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_launcher_type),
+    offsetof(CMsgClientLogon, launcher_type),
+    NULL,
+    &cmsg_client_logon__launcher_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ui_mode",
+    32,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_ui_mode),
+    offsetof(CMsgClientLogon, ui_mode),
+    NULL,
+    &cmsg_client_logon__ui_mode__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "chat_mode",
+    33,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_chat_mode),
+    offsetof(CMsgClientLogon, chat_mode),
+    NULL,
+    &cmsg_client_logon__chat_mode__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steam2_auth_ticket",
+    41,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientLogon, has_steam2_auth_ticket),
+    offsetof(CMsgClientLogon, steam2_auth_ticket),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "email_address",
+    42,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, email_address),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_account_creation",
+    43,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED32,
+    offsetof(CMsgClientLogon, has_rtime32_account_creation),
+    offsetof(CMsgClientLogon, rtime32_account_creation),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "account_name",
+    50,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, account_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "password",
+    51,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, password),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "game_server_token",
+    52,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, game_server_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "login_key",
+    60,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, login_key),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "was_converted_deprecated_msg",
+    70,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_was_converted_deprecated_msg),
+    offsetof(CMsgClientLogon, was_converted_deprecated_msg),
+    NULL,
+    &cmsg_client_logon__was_converted_deprecated_msg__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "anon_user_target_account_name",
+    80,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, anon_user_target_account_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "resolved_user_steam_id",
+    81,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgClientLogon, has_resolved_user_steam_id),
+    offsetof(CMsgClientLogon, resolved_user_steam_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "eresult_sentryfile",
+    82,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogon, has_eresult_sentryfile),
+    offsetof(CMsgClientLogon, eresult_sentryfile),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "sha_sentryfile",
+    83,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientLogon, has_sha_sentryfile),
+    offsetof(CMsgClientLogon, sha_sentryfile),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "auth_code",
+    84,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, auth_code),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "otp_type",
+    85,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogon, has_otp_type),
+    offsetof(CMsgClientLogon, otp_type),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "otp_value",
+    86,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogon, has_otp_value),
+    offsetof(CMsgClientLogon, otp_value),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "otp_identifier",
+    87,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, otp_identifier),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steam2_ticket_request",
+    88,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_steam2_ticket_request),
+    offsetof(CMsgClientLogon, steam2_ticket_request),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "sony_psn_ticket",
+    90,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientLogon, has_sony_psn_ticket),
+    offsetof(CMsgClientLogon, sony_psn_ticket),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "sony_psn_service_id",
+    91,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, sony_psn_service_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "create_new_psn_linked_account_if_needed",
+    92,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_create_new_psn_linked_account_if_needed),
+    offsetof(CMsgClientLogon, create_new_psn_linked_account_if_needed),
+    NULL,
+    &cmsg_client_logon__create_new_psn_linked_account_if_needed__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "sony_psn_name",
+    93,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, sony_psn_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "game_server_app_id",
+    94,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogon, has_game_server_app_id),
+    offsetof(CMsgClientLogon, game_server_app_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamguard_dont_remember_computer",
+    95,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_steamguard_dont_remember_computer),
+    offsetof(CMsgClientLogon, steamguard_dont_remember_computer),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "machine_name",
+    96,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, machine_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "machine_name_userchosen",
+    97,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, machine_name_userchosen),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "country_override",
+    98,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, country_override),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_steam_box",
+    99,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_is_steam_box),
+    offsetof(CMsgClientLogon, is_steam_box),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_instance_id",
+    100,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgClientLogon, has_client_instance_id),
+    offsetof(CMsgClientLogon, client_instance_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "two_factor_code",
+    101,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, two_factor_code),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "supports_rate_limit_response",
+    102,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_supports_rate_limit_response),
+    offsetof(CMsgClientLogon, supports_rate_limit_response),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "web_logon_nonce",
+    103,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, web_logon_nonce),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "priority_reason",
+    104,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogon, has_priority_reason),
+    offsetof(CMsgClientLogon, priority_reason),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "embedded_client_secret",
+    105,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, embedded_client_secret),
+    &cmsg_client_secret__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "disable_partner_autogrants",
+    106,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_disable_partner_autogrants),
+    offsetof(CMsgClientLogon, disable_partner_autogrants),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_steam_deck",
+    107,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_is_steam_deck),
+    offsetof(CMsgClientLogon, is_steam_deck),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "access_token",
+    108,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogon, access_token),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_chrome_os",
+    109,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_is_chrome_os),
+    offsetof(CMsgClientLogon, is_chrome_os),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_tesla",
+    110,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogon, has_is_tesla),
+    offsetof(CMsgClientLogon, is_tesla),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_logon__field_indices_by_name[] = {
+  54,   /* field[54] = access_token */
+  22,   /* field[22] = account_name */
+  27,   /* field[27] = anon_user_target_account_name */
+  31,   /* field[31] = auth_code */
+  2,   /* field[2] = cell_id */
+  18,   /* field[18] = chat_mode */
+  46,   /* field[46] = client_instance_id */
+  5,   /* field[5] = client_language */
+  6,   /* field[6] = client_os_type */
+  4,   /* field[4] = client_package_version */
+  13,   /* field[13] = client_supplied_steam_id */
+  44,   /* field[44] = country_override */
+  38,   /* field[38] = create_new_psn_linked_account_if_needed */
+  9,   /* field[9] = deprecated_10 */
+  1,   /* field[1] = deprecated_obfustucated_private_ip */
+  11,   /* field[11] = deprecated_public_ip */
+  52,   /* field[52] = disable_partner_autogrants */
+  20,   /* field[20] = email_address */
+  51,   /* field[51] = embedded_client_secret */
+  29,   /* field[29] = eresult_sentryfile */
+  40,   /* field[40] = game_server_app_id */
+  24,   /* field[24] = game_server_token */
+  55,   /* field[55] = is_chrome_os */
+  45,   /* field[45] = is_steam_box */
+  53,   /* field[53] = is_steam_deck */
+  56,   /* field[56] = is_tesla */
+  3,   /* field[3] = last_session_id */
+  16,   /* field[16] = launcher_type */
+  25,   /* field[25] = login_key */
+  15,   /* field[15] = machine_id */
+  42,   /* field[42] = machine_name */
+  43,   /* field[43] = machine_name_userchosen */
+  10,   /* field[10] = obfuscated_private_ip */
+  34,   /* field[34] = otp_identifier */
+  32,   /* field[32] = otp_type */
+  33,   /* field[33] = otp_value */
+  23,   /* field[23] = password */
+  50,   /* field[50] = priority_reason */
+  0,   /* field[0] = protocol_version */
+  14,   /* field[14] = public_ip */
+  12,   /* field[12] = qos_level */
+  28,   /* field[28] = resolved_user_steam_id */
+  21,   /* field[21] = rtime32_account_creation */
+  30,   /* field[30] = sha_sentryfile */
+  7,   /* field[7] = should_remember_password */
+  39,   /* field[39] = sony_psn_name */
+  37,   /* field[37] = sony_psn_service_id */
+  36,   /* field[36] = sony_psn_ticket */
+  19,   /* field[19] = steam2_auth_ticket */
+  35,   /* field[35] = steam2_ticket_request */
+  41,   /* field[41] = steamguard_dont_remember_computer */
+  48,   /* field[48] = supports_rate_limit_response */
+  47,   /* field[47] = two_factor_code */
+  17,   /* field[17] = ui_mode */
+  26,   /* field[26] = was_converted_deprecated_msg */
+  49,   /* field[49] = web_logon_nonce */
+  8,   /* field[8] = wine_version */
+};
+static const ProtobufCIntRange cmsg_client_logon__number_ranges[9 + 1] =
+{
+  { 1, 0 },
+  { 20, 11 },
+  { 30, 15 },
+  { 41, 19 },
+  { 50, 22 },
+  { 60, 25 },
+  { 70, 26 },
+  { 80, 27 },
+  { 90, 36 },
+  { 0, 57 }
+};
+const ProtobufCMessageDescriptor cmsg_client_logon__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientLogon",
+  "CMsgClientLogon",
+  "CMsgClientLogon",
+  "",
+  sizeof(CMsgClientLogon),
+  57,
+  cmsg_client_logon__field_descriptors,
+  cmsg_client_logon__field_indices_by_name,
+  9,  cmsg_client_logon__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const int32_t cmsg_client_logon_response__eresult__default_value = 2;
+static const ProtobufCFieldDescriptor cmsg_client_logon_response__field_descriptors[26] =
+{
+  {
+    "eresult",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogonResponse, has_eresult),
+    offsetof(CMsgClientLogonResponse, eresult),
+    NULL,
+    &cmsg_client_logon_response__eresult__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "legacy_out_of_game_heartbeat_seconds",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogonResponse, has_legacy_out_of_game_heartbeat_seconds),
+    offsetof(CMsgClientLogonResponse, legacy_out_of_game_heartbeat_seconds),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "heartbeat_seconds",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogonResponse, has_heartbeat_seconds),
+    offsetof(CMsgClientLogonResponse, heartbeat_seconds),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "deprecated_public_ip",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogonResponse, has_deprecated_public_ip),
+    offsetof(CMsgClientLogonResponse, deprecated_public_ip),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "rtime32_server_time",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED32,
+    offsetof(CMsgClientLogonResponse, has_rtime32_server_time),
+    offsetof(CMsgClientLogonResponse, rtime32_server_time),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "account_flags",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogonResponse, has_account_flags),
+    offsetof(CMsgClientLogonResponse, account_flags),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "cell_id",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogonResponse, has_cell_id),
+    offsetof(CMsgClientLogonResponse, cell_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "email_domain",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogonResponse, email_domain),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steam2_ticket",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientLogonResponse, has_steam2_ticket),
+    offsetof(CMsgClientLogonResponse, steam2_ticket),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "eresult_extended",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogonResponse, has_eresult_extended),
+    offsetof(CMsgClientLogonResponse, eresult_extended),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "webapi_authenticate_user_nonce",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogonResponse, webapi_authenticate_user_nonce),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "cell_id_ping_threshold",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientLogonResponse, has_cell_id_ping_threshold),
+    offsetof(CMsgClientLogonResponse, cell_id_ping_threshold),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "deprecated_use_pics",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogonResponse, has_deprecated_use_pics),
+    offsetof(CMsgClientLogonResponse, deprecated_use_pics),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "vanity_url",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogonResponse, vanity_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "public_ip",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogonResponse, public_ip),
+    &cmsg_ipaddress__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_supplied_steamid",
+    20,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgClientLogonResponse, has_client_supplied_steamid),
+    offsetof(CMsgClientLogonResponse, client_supplied_steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ip_country_code",
+    21,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogonResponse, ip_country_code),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "parental_settings",
+    22,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientLogonResponse, has_parental_settings),
+    offsetof(CMsgClientLogonResponse, parental_settings),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "parental_setting_signature",
+    23,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(CMsgClientLogonResponse, has_parental_setting_signature),
+    offsetof(CMsgClientLogonResponse, parental_setting_signature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "count_loginfailures_to_migrate",
+    24,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogonResponse, has_count_loginfailures_to_migrate),
+    offsetof(CMsgClientLogonResponse, count_loginfailures_to_migrate),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "count_disconnects_to_migrate",
+    25,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogonResponse, has_count_disconnects_to_migrate),
+    offsetof(CMsgClientLogonResponse, count_disconnects_to_migrate),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ogs_data_report_time_window",
+    26,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLogonResponse, has_ogs_data_report_time_window),
+    offsetof(CMsgClientLogonResponse, ogs_data_report_time_window),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "client_instance_id",
+    27,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgClientLogonResponse, has_client_instance_id),
+    offsetof(CMsgClientLogonResponse, client_instance_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "force_client_update_check",
+    28,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientLogonResponse, has_force_client_update_check),
+    offsetof(CMsgClientLogonResponse, force_client_update_check),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "agreement_session_url",
+    29,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientLogonResponse, agreement_session_url),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_id",
+    30,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgClientLogonResponse, has_token_id),
+    offsetof(CMsgClientLogonResponse, token_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_logon_response__field_indices_by_name[] = {
+  5,   /* field[5] = account_flags */
+  24,   /* field[24] = agreement_session_url */
+  6,   /* field[6] = cell_id */
+  11,   /* field[11] = cell_id_ping_threshold */
+  22,   /* field[22] = client_instance_id */
+  15,   /* field[15] = client_supplied_steamid */
+  20,   /* field[20] = count_disconnects_to_migrate */
+  19,   /* field[19] = count_loginfailures_to_migrate */
+  3,   /* field[3] = deprecated_public_ip */
+  12,   /* field[12] = deprecated_use_pics */
+  7,   /* field[7] = email_domain */
+  0,   /* field[0] = eresult */
+  9,   /* field[9] = eresult_extended */
+  23,   /* field[23] = force_client_update_check */
+  2,   /* field[2] = heartbeat_seconds */
+  16,   /* field[16] = ip_country_code */
+  1,   /* field[1] = legacy_out_of_game_heartbeat_seconds */
+  21,   /* field[21] = ogs_data_report_time_window */
+  18,   /* field[18] = parental_setting_signature */
+  17,   /* field[17] = parental_settings */
+  14,   /* field[14] = public_ip */
+  4,   /* field[4] = rtime32_server_time */
+  8,   /* field[8] = steam2_ticket */
+  25,   /* field[25] = token_id */
+  13,   /* field[13] = vanity_url */
+  10,   /* field[10] = webapi_authenticate_user_nonce */
+};
+static const ProtobufCIntRange cmsg_client_logon_response__number_ranges[2 + 1] =
+{
+  { 1, 0 },
+  { 20, 15 },
+  { 0, 26 }
+};
+const ProtobufCMessageDescriptor cmsg_client_logon_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientLogonResponse",
+  "CMsgClientLogonResponse",
+  "CMsgClientLogonResponse",
+  "",
+  sizeof(CMsgClientLogonResponse),
+  26,
+  cmsg_client_logon_response__field_descriptors,
+  cmsg_client_logon_response__field_indices_by_name,
+  2,  cmsg_client_logon_response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const int32_t cmsg_client_request_web_apiauthenticate_user_nonce__token_type__default_value = -1;
+static const ProtobufCFieldDescriptor cmsg_client_request_web_apiauthenticate_user_nonce__field_descriptors[1] =
+{
+  {
+    "token_type",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientRequestWebAPIAuthenticateUserNonce, has_token_type),
+    offsetof(CMsgClientRequestWebAPIAuthenticateUserNonce, token_type),
+    NULL,
+    &cmsg_client_request_web_apiauthenticate_user_nonce__token_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_request_web_apiauthenticate_user_nonce__field_indices_by_name[] = {
+  0,   /* field[0] = token_type */
+};
+static const ProtobufCIntRange cmsg_client_request_web_apiauthenticate_user_nonce__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_request_web_apiauthenticate_user_nonce__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientRequestWebAPIAuthenticateUserNonce",
+  "CMsgClientRequestWebAPIAuthenticateUserNonce",
+  "CMsgClientRequestWebAPIAuthenticateUserNonce",
+  "",
+  sizeof(CMsgClientRequestWebAPIAuthenticateUserNonce),
+  1,
+  cmsg_client_request_web_apiauthenticate_user_nonce__field_descriptors,
+  cmsg_client_request_web_apiauthenticate_user_nonce__field_indices_by_name,
+  1,  cmsg_client_request_web_apiauthenticate_user_nonce__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const int32_t cmsg_client_request_web_apiauthenticate_user_nonce_response__eresult__default_value = 2;
+static const int32_t cmsg_client_request_web_apiauthenticate_user_nonce_response__token_type__default_value = -1;
+static const ProtobufCFieldDescriptor cmsg_client_request_web_apiauthenticate_user_nonce_response__field_descriptors[3] =
+{
+  {
+    "eresult",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientRequestWebAPIAuthenticateUserNonceResponse, has_eresult),
+    offsetof(CMsgClientRequestWebAPIAuthenticateUserNonceResponse, eresult),
+    NULL,
+    &cmsg_client_request_web_apiauthenticate_user_nonce_response__eresult__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "token_type",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientRequestWebAPIAuthenticateUserNonceResponse, has_token_type),
+    offsetof(CMsgClientRequestWebAPIAuthenticateUserNonceResponse, token_type),
+    NULL,
+    &cmsg_client_request_web_apiauthenticate_user_nonce_response__token_type__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "webapi_authenticate_user_nonce",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientRequestWebAPIAuthenticateUserNonceResponse, webapi_authenticate_user_nonce),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_request_web_apiauthenticate_user_nonce_response__field_indices_by_name[] = {
+  0,   /* field[0] = eresult */
+  1,   /* field[1] = token_type */
+  2,   /* field[2] = webapi_authenticate_user_nonce */
+};
+static const ProtobufCIntRange cmsg_client_request_web_apiauthenticate_user_nonce_response__number_ranges[3 + 1] =
+{
+  { 1, 0 },
+  { 3, 1 },
+  { 11, 2 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientRequestWebAPIAuthenticateUserNonceResponse",
+  "CMsgClientRequestWebAPIAuthenticateUserNonceResponse",
+  "CMsgClientRequestWebAPIAuthenticateUserNonceResponse",
+  "",
+  sizeof(CMsgClientRequestWebAPIAuthenticateUserNonceResponse),
+  3,
+  cmsg_client_request_web_apiauthenticate_user_nonce_response__field_descriptors,
+  cmsg_client_request_web_apiauthenticate_user_nonce_response__field_indices_by_name,
+  3,  cmsg_client_request_web_apiauthenticate_user_nonce_response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+#define cmsg_client_log_off__field_descriptors NULL
+#define cmsg_client_log_off__field_indices_by_name NULL
+#define cmsg_client_log_off__number_ranges NULL
+const ProtobufCMessageDescriptor cmsg_client_log_off__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientLogOff",
+  "CMsgClientLogOff",
+  "CMsgClientLogOff",
+  "",
+  sizeof(CMsgClientLogOff),
+  0,
+  cmsg_client_log_off__field_descriptors,
+  cmsg_client_log_off__field_indices_by_name,
+  0,  cmsg_client_log_off__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const int32_t cmsg_client_logged_off__eresult__default_value = 2;
+static const ProtobufCFieldDescriptor cmsg_client_logged_off__field_descriptors[1] =
+{
+  {
+    "eresult",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientLoggedOff, has_eresult),
+    offsetof(CMsgClientLoggedOff, eresult),
+    NULL,
+    &cmsg_client_logged_off__eresult__default_value,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_logged_off__field_indices_by_name[] = {
+  0,   /* field[0] = eresult */
+};
+static const ProtobufCIntRange cmsg_client_logged_off__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_logged_off__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientLoggedOff",
+  "CMsgClientLoggedOff",
+  "CMsgClientLoggedOff",
+  "",
+  sizeof(CMsgClientLoggedOff),
+  1,
+  cmsg_client_logged_off__field_descriptors,
+  cmsg_client_logged_off__field_indices_by_name,
+  1,  cmsg_client_logged_off__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_new_login_key__field_descriptors[2] =
+{
+  {
+    "unique_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientNewLoginKey, has_unique_id),
+    offsetof(CMsgClientNewLoginKey, unique_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "login_key",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientNewLoginKey, login_key),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_new_login_key__field_indices_by_name[] = {
+  1,   /* field[1] = login_key */
+  0,   /* field[0] = unique_id */
+};
+static const ProtobufCIntRange cmsg_client_new_login_key__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor cmsg_client_new_login_key__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientNewLoginKey",
+  "CMsgClientNewLoginKey",
+  "CMsgClientNewLoginKey",
+  "",
+  sizeof(CMsgClientNewLoginKey),
+  2,
+  cmsg_client_new_login_key__field_descriptors,
+  cmsg_client_new_login_key__field_indices_by_name,
+  1,  cmsg_client_new_login_key__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_new_login_key_accepted__field_descriptors[1] =
+{
+  {
+    "unique_id",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientNewLoginKeyAccepted, has_unique_id),
+    offsetof(CMsgClientNewLoginKeyAccepted, unique_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_new_login_key_accepted__field_indices_by_name[] = {
+  0,   /* field[0] = unique_id */
+};
+static const ProtobufCIntRange cmsg_client_new_login_key_accepted__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_new_login_key_accepted__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientNewLoginKeyAccepted",
+  "CMsgClientNewLoginKeyAccepted",
+  "CMsgClientNewLoginKeyAccepted",
+  "",
+  sizeof(CMsgClientNewLoginKeyAccepted),
+  1,
+  cmsg_client_new_login_key_accepted__field_descriptors,
+  cmsg_client_new_login_key_accepted__field_indices_by_name,
+  1,  cmsg_client_new_login_key_accepted__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_account_info__field_descriptors[11] =
+{
+  {
+    "persona_name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientAccountInfo, persona_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ip_country",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientAccountInfo, ip_country),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "count_authed_computers",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(CMsgClientAccountInfo, has_count_authed_computers),
+    offsetof(CMsgClientAccountInfo, count_authed_computers),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "account_flags",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientAccountInfo, has_account_flags),
+    offsetof(CMsgClientAccountInfo, account_flags),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "facebook_id",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT64,
+    offsetof(CMsgClientAccountInfo, has_facebook_id),
+    offsetof(CMsgClientAccountInfo, facebook_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "facebook_name",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientAccountInfo, facebook_name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "steamguard_machine_name_user_chosen",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CMsgClientAccountInfo, steamguard_machine_name_user_chosen),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_phone_verified",
+    16,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientAccountInfo, has_is_phone_verified),
+    offsetof(CMsgClientAccountInfo, is_phone_verified),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "two_factor_state",
+    17,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(CMsgClientAccountInfo, has_two_factor_state),
+    offsetof(CMsgClientAccountInfo, two_factor_state),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_phone_identifying",
+    18,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientAccountInfo, has_is_phone_identifying),
+    offsetof(CMsgClientAccountInfo, is_phone_identifying),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "is_phone_needing_reverify",
+    19,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(CMsgClientAccountInfo, has_is_phone_needing_reverify),
+    offsetof(CMsgClientAccountInfo, is_phone_needing_reverify),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_account_info__field_indices_by_name[] = {
+  3,   /* field[3] = account_flags */
+  2,   /* field[2] = count_authed_computers */
+  4,   /* field[4] = facebook_id */
+  5,   /* field[5] = facebook_name */
+  1,   /* field[1] = ip_country */
+  9,   /* field[9] = is_phone_identifying */
+  10,   /* field[10] = is_phone_needing_reverify */
+  7,   /* field[7] = is_phone_verified */
+  0,   /* field[0] = persona_name */
+  6,   /* field[6] = steamguard_machine_name_user_chosen */
+  8,   /* field[8] = two_factor_state */
+};
+static const ProtobufCIntRange cmsg_client_account_info__number_ranges[4 + 1] =
+{
+  { 1, 0 },
+  { 5, 2 },
+  { 7, 3 },
+  { 15, 6 },
+  { 0, 11 }
+};
+const ProtobufCMessageDescriptor cmsg_client_account_info__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientAccountInfo",
+  "CMsgClientAccountInfo",
+  "CMsgClientAccountInfo",
+  "",
+  sizeof(CMsgClientAccountInfo),
+  11,
+  cmsg_client_account_info__field_descriptors,
+  cmsg_client_account_info__field_indices_by_name,
+  4,  cmsg_client_account_info__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_challenge_request__field_descriptors[1] =
+{
+  {
+    "steamid",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgClientChallengeRequest, has_steamid),
+    offsetof(CMsgClientChallengeRequest, steamid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_challenge_request__field_indices_by_name[] = {
+  0,   /* field[0] = steamid */
+};
+static const ProtobufCIntRange cmsg_client_challenge_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_challenge_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientChallengeRequest",
+  "CMsgClientChallengeRequest",
+  "CMsgClientChallengeRequest",
+  "",
+  sizeof(CMsgClientChallengeRequest),
+  1,
+  cmsg_client_challenge_request__field_descriptors,
+  cmsg_client_challenge_request__field_indices_by_name,
+  1,  cmsg_client_challenge_request__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor cmsg_client_challenge_response__field_descriptors[1] =
+{
+  {
+    "challenge",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_FIXED64,
+    offsetof(CMsgClientChallengeResponse, has_challenge),
+    offsetof(CMsgClientChallengeResponse, challenge),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned cmsg_client_challenge_response__field_indices_by_name[] = {
+  0,   /* field[0] = challenge */
+};
+static const ProtobufCIntRange cmsg_client_challenge_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor cmsg_client_challenge_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CMsgClientChallengeResponse",
+  "CMsgClientChallengeResponse",
+  "CMsgClientChallengeResponse",
+  "",
+  sizeof(CMsgClientChallengeResponse),
+  1,
+  cmsg_client_challenge_response__field_descriptors,
+  cmsg_client_challenge_response__field_indices_by_name,
+  1,  cmsg_client_challenge_response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.pb-c.h b/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.pb-c.h
new file mode 100644
index 0000000000..d777edf30e
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.pb-c.h
@@ -0,0 +1,697 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_clientserver_login.proto */
+
+#ifndef PROTOBUF_C_steammessages_5fclientserver_5flogin_2eproto__INCLUDED
+#define PROTOBUF_C_steammessages_5fclientserver_5flogin_2eproto__INCLUDED
+
+#include "protobuf-c.h"
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1000000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "steammessages_base.pb-c.h"
+
+struct CMsgClientHeartBeat;
+struct CMsgClientServerTimestampRequest;
+struct CMsgClientServerTimestampResponse;
+struct CMsgClientSecret;
+struct CMsgClientHello;
+struct CMsgClientLogon;
+struct CMsgClientLogonResponse;
+struct CMsgClientRequestWebAPIAuthenticateUserNonce;
+struct CMsgClientRequestWebAPIAuthenticateUserNonceResponse;
+struct CMsgClientLogOff;
+struct CMsgClientLoggedOff;
+struct CMsgClientNewLoginKey;
+struct CMsgClientNewLoginKeyAccepted;
+struct CMsgClientAccountInfo;
+struct CMsgClientChallengeRequest;
+struct CMsgClientChallengeResponse;
+
+
+/* --- enums --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor cmsg_client_heart_beat__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_server_timestamp_request__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_server_timestamp_response__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_secret__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_hello__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_logon__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_logon_response__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_request_web_apiauthenticate_user_nonce__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_log_off__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_logged_off__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_new_login_key__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_new_login_key_accepted__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_account_info__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_challenge_request__descriptor;
+extern const ProtobufCMessageDescriptor cmsg_client_challenge_response__descriptor;
+
+/* --- messages --- */
+
+struct CMsgClientHeartBeat : public ProtobufCppMessage
+{
+  CMsgClientHeartBeat() :
+     ProtobufCppMessage(cmsg_client_heart_beat__descriptor)
+  {}
+
+  protobuf_c_boolean has_send_reply;
+  protobuf_c_boolean send_reply;
+};
+
+struct CMsgClientServerTimestampRequest : public ProtobufCppMessage
+{
+  CMsgClientServerTimestampRequest() :
+     ProtobufCppMessage(cmsg_client_server_timestamp_request__descriptor)
+  {}
+
+  protobuf_c_boolean has_client_request_timestamp;
+  uint64_t client_request_timestamp;
+};
+
+struct CMsgClientServerTimestampResponse : public ProtobufCppMessage
+{
+  CMsgClientServerTimestampResponse() :
+     ProtobufCppMessage(cmsg_client_server_timestamp_response__descriptor)
+  {}
+
+  protobuf_c_boolean has_client_request_timestamp;
+  uint64_t client_request_timestamp;
+  protobuf_c_boolean has_server_timestamp_ms;
+  uint64_t server_timestamp_ms;
+};
+
+struct CMsgClientSecret : public ProtobufCppMessage
+{
+  CMsgClientSecret() :
+     ProtobufCppMessage(cmsg_client_secret__descriptor)
+  {}
+
+  protobuf_c_boolean has_version;
+  uint32_t version;
+  protobuf_c_boolean has_appid;
+  uint32_t appid;
+  protobuf_c_boolean has_deviceid;
+  uint32_t deviceid;
+  protobuf_c_boolean has_nonce;
+  uint64_t nonce;
+  protobuf_c_boolean has_hmac;
+  ProtobufCBinaryData hmac;
+};
+
+struct CMsgClientHello : public ProtobufCppMessage
+{
+  CMsgClientHello() :
+     ProtobufCppMessage(cmsg_client_hello__descriptor)
+  {}
+
+  protobuf_c_boolean has_protocol_version;
+  uint32_t protocol_version;
+};
+
+struct CMsgClientLogon : public ProtobufCppMessage
+{
+  CMsgClientLogon() :
+     ProtobufCppMessage(cmsg_client_logon__descriptor)
+  {}
+
+  protobuf_c_boolean has_protocol_version;
+  uint32_t protocol_version;
+  protobuf_c_boolean has_deprecated_obfustucated_private_ip;
+  uint32_t deprecated_obfustucated_private_ip;
+  protobuf_c_boolean has_cell_id;
+  uint32_t cell_id;
+  protobuf_c_boolean has_last_session_id;
+  uint32_t last_session_id;
+  protobuf_c_boolean has_client_package_version;
+  uint32_t client_package_version;
+  char *client_language;
+  protobuf_c_boolean has_client_os_type;
+  uint32_t client_os_type;
+  protobuf_c_boolean has_should_remember_password;
+  protobuf_c_boolean should_remember_password;
+  char *wine_version;
+  protobuf_c_boolean has_deprecated_10;
+  uint32_t deprecated_10;
+  CMsgIPAddress *obfuscated_private_ip;
+  protobuf_c_boolean has_deprecated_public_ip;
+  uint32_t deprecated_public_ip;
+  protobuf_c_boolean has_qos_level;
+  uint32_t qos_level;
+  protobuf_c_boolean has_client_supplied_steam_id;
+  uint64_t client_supplied_steam_id;
+  CMsgIPAddress *public_ip;
+  protobuf_c_boolean has_machine_id;
+  ProtobufCBinaryData machine_id;
+  protobuf_c_boolean has_launcher_type;
+  uint32_t launcher_type;
+  protobuf_c_boolean has_ui_mode;
+  uint32_t ui_mode;
+  protobuf_c_boolean has_chat_mode;
+  uint32_t chat_mode;
+  protobuf_c_boolean has_steam2_auth_ticket;
+  ProtobufCBinaryData steam2_auth_ticket;
+  char *email_address;
+  protobuf_c_boolean has_rtime32_account_creation;
+  uint32_t rtime32_account_creation;
+  char *account_name;
+  char *password;
+  char *game_server_token;
+  char *login_key;
+  protobuf_c_boolean has_was_converted_deprecated_msg;
+  protobuf_c_boolean was_converted_deprecated_msg;
+  char *anon_user_target_account_name;
+  protobuf_c_boolean has_resolved_user_steam_id;
+  uint64_t resolved_user_steam_id;
+  protobuf_c_boolean has_eresult_sentryfile;
+  int32_t eresult_sentryfile;
+  protobuf_c_boolean has_sha_sentryfile;
+  ProtobufCBinaryData sha_sentryfile;
+  char *auth_code;
+  protobuf_c_boolean has_otp_type;
+  int32_t otp_type;
+  protobuf_c_boolean has_otp_value;
+  uint32_t otp_value;
+  char *otp_identifier;
+  protobuf_c_boolean has_steam2_ticket_request;
+  protobuf_c_boolean steam2_ticket_request;
+  protobuf_c_boolean has_sony_psn_ticket;
+  ProtobufCBinaryData sony_psn_ticket;
+  char *sony_psn_service_id;
+  protobuf_c_boolean has_create_new_psn_linked_account_if_needed;
+  protobuf_c_boolean create_new_psn_linked_account_if_needed;
+  char *sony_psn_name;
+  protobuf_c_boolean has_game_server_app_id;
+  int32_t game_server_app_id;
+  protobuf_c_boolean has_steamguard_dont_remember_computer;
+  protobuf_c_boolean steamguard_dont_remember_computer;
+  char *machine_name;
+  char *machine_name_userchosen;
+  char *country_override;
+  protobuf_c_boolean has_is_steam_box;
+  protobuf_c_boolean is_steam_box;
+  protobuf_c_boolean has_client_instance_id;
+  uint64_t client_instance_id;
+  char *two_factor_code;
+  protobuf_c_boolean has_supports_rate_limit_response;
+  protobuf_c_boolean supports_rate_limit_response;
+  char *web_logon_nonce;
+  protobuf_c_boolean has_priority_reason;
+  int32_t priority_reason;
+  CMsgClientSecret *embedded_client_secret;
+  protobuf_c_boolean has_disable_partner_autogrants;
+  protobuf_c_boolean disable_partner_autogrants;
+  protobuf_c_boolean has_is_steam_deck;
+  protobuf_c_boolean is_steam_deck;
+  char *access_token;
+  protobuf_c_boolean has_is_chrome_os;
+  protobuf_c_boolean is_chrome_os;
+  protobuf_c_boolean has_is_tesla;
+  protobuf_c_boolean is_tesla;
+};
+
+struct CMsgClientLogonResponse : public ProtobufCppMessage
+{
+  CMsgClientLogonResponse() :
+     ProtobufCppMessage(cmsg_client_logon_response__descriptor)
+  {}
+
+  protobuf_c_boolean has_eresult;
+  int32_t eresult;
+  protobuf_c_boolean has_legacy_out_of_game_heartbeat_seconds;
+  int32_t legacy_out_of_game_heartbeat_seconds;
+  protobuf_c_boolean has_heartbeat_seconds;
+  int32_t heartbeat_seconds;
+  protobuf_c_boolean has_deprecated_public_ip;
+  uint32_t deprecated_public_ip;
+  protobuf_c_boolean has_rtime32_server_time;
+  uint32_t rtime32_server_time;
+  protobuf_c_boolean has_account_flags;
+  uint32_t account_flags;
+  protobuf_c_boolean has_cell_id;
+  uint32_t cell_id;
+  char *email_domain;
+  protobuf_c_boolean has_steam2_ticket;
+  ProtobufCBinaryData steam2_ticket;
+  protobuf_c_boolean has_eresult_extended;
+  int32_t eresult_extended;
+  char *webapi_authenticate_user_nonce;
+  protobuf_c_boolean has_cell_id_ping_threshold;
+  uint32_t cell_id_ping_threshold;
+  protobuf_c_boolean has_deprecated_use_pics;
+  protobuf_c_boolean deprecated_use_pics;
+  char *vanity_url;
+  CMsgIPAddress *public_ip;
+  protobuf_c_boolean has_client_supplied_steamid;
+  uint64_t client_supplied_steamid;
+  char *ip_country_code;
+  protobuf_c_boolean has_parental_settings;
+  ProtobufCBinaryData parental_settings;
+  protobuf_c_boolean has_parental_setting_signature;
+  ProtobufCBinaryData parental_setting_signature;
+  protobuf_c_boolean has_count_loginfailures_to_migrate;
+  int32_t count_loginfailures_to_migrate;
+  protobuf_c_boolean has_count_disconnects_to_migrate;
+  int32_t count_disconnects_to_migrate;
+  protobuf_c_boolean has_ogs_data_report_time_window;
+  int32_t ogs_data_report_time_window;
+  protobuf_c_boolean has_client_instance_id;
+  uint64_t client_instance_id;
+  protobuf_c_boolean has_force_client_update_check;
+  protobuf_c_boolean force_client_update_check;
+  char *agreement_session_url;
+  protobuf_c_boolean has_token_id;
+  uint64_t token_id;
+};
+
+struct CMsgClientRequestWebAPIAuthenticateUserNonce : public ProtobufCppMessage
+{
+  CMsgClientRequestWebAPIAuthenticateUserNonce() :
+     ProtobufCppMessage(cmsg_client_request_web_apiauthenticate_user_nonce__descriptor)
+  {}
+
+  protobuf_c_boolean has_token_type;
+  int32_t token_type;
+};
+
+struct CMsgClientRequestWebAPIAuthenticateUserNonceResponse : public ProtobufCppMessage
+{
+  CMsgClientRequestWebAPIAuthenticateUserNonceResponse() :
+     ProtobufCppMessage(cmsg_client_request_web_apiauthenticate_user_nonce_response__descriptor)
+  {}
+
+  protobuf_c_boolean has_eresult;
+  int32_t eresult;
+  char *webapi_authenticate_user_nonce;
+  protobuf_c_boolean has_token_type;
+  int32_t token_type;
+};
+
+struct CMsgClientLogOff : public ProtobufCppMessage
+{
+  CMsgClientLogOff() :
+     ProtobufCppMessage(cmsg_client_log_off__descriptor)
+  {}
+
+};
+
+struct CMsgClientLoggedOff : public ProtobufCppMessage
+{
+  CMsgClientLoggedOff() :
+     ProtobufCppMessage(cmsg_client_logged_off__descriptor)
+  {}
+
+  protobuf_c_boolean has_eresult;
+  int32_t eresult;
+};
+
+struct CMsgClientNewLoginKey : public ProtobufCppMessage
+{
+  CMsgClientNewLoginKey() :
+     ProtobufCppMessage(cmsg_client_new_login_key__descriptor)
+  {}
+
+  protobuf_c_boolean has_unique_id;
+  uint32_t unique_id;
+  char *login_key;
+};
+
+struct CMsgClientNewLoginKeyAccepted : public ProtobufCppMessage
+{
+  CMsgClientNewLoginKeyAccepted() :
+     ProtobufCppMessage(cmsg_client_new_login_key_accepted__descriptor)
+  {}
+
+  protobuf_c_boolean has_unique_id;
+  uint32_t unique_id;
+};
+
+struct CMsgClientAccountInfo : public ProtobufCppMessage
+{
+  CMsgClientAccountInfo() :
+     ProtobufCppMessage(cmsg_client_account_info__descriptor)
+  {}
+
+  char *persona_name;
+  char *ip_country;
+  protobuf_c_boolean has_count_authed_computers;
+  int32_t count_authed_computers;
+  protobuf_c_boolean has_account_flags;
+  uint32_t account_flags;
+  protobuf_c_boolean has_facebook_id;
+  uint64_t facebook_id;
+  char *facebook_name;
+  char *steamguard_machine_name_user_chosen;
+  protobuf_c_boolean has_is_phone_verified;
+  protobuf_c_boolean is_phone_verified;
+  protobuf_c_boolean has_two_factor_state;
+  uint32_t two_factor_state;
+  protobuf_c_boolean has_is_phone_identifying;
+  protobuf_c_boolean is_phone_identifying;
+  protobuf_c_boolean has_is_phone_needing_reverify;
+  protobuf_c_boolean is_phone_needing_reverify;
+};
+
+struct CMsgClientChallengeRequest : public ProtobufCppMessage
+{
+  CMsgClientChallengeRequest() :
+     ProtobufCppMessage(cmsg_client_challenge_request__descriptor)
+  {}
+
+  protobuf_c_boolean has_steamid;
+  uint64_t steamid;
+};
+
+struct CMsgClientChallengeResponse : public ProtobufCppMessage
+{
+  CMsgClientChallengeResponse() :
+     ProtobufCppMessage(cmsg_client_challenge_response__descriptor)
+  {}
+
+  protobuf_c_boolean has_challenge;
+  uint64_t challenge;
+};
+
+size_t cmsg_client_heart_beat__get_packed_size
+                     (const CMsgClientHeartBeat   *message);
+size_t cmsg_client_heart_beat__pack
+                     (const CMsgClientHeartBeat   *message,
+                      uint8_t             *out);
+size_t cmsg_client_heart_beat__pack_to_buffer
+                     (const CMsgClientHeartBeat   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientHeartBeat *
+       cmsg_client_heart_beat__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_heart_beat__free_unpacked
+                     (CMsgClientHeartBeat *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_server_timestamp_request__get_packed_size
+                     (const CMsgClientServerTimestampRequest   *message);
+size_t cmsg_client_server_timestamp_request__pack
+                     (const CMsgClientServerTimestampRequest   *message,
+                      uint8_t             *out);
+size_t cmsg_client_server_timestamp_request__pack_to_buffer
+                     (const CMsgClientServerTimestampRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientServerTimestampRequest *
+       cmsg_client_server_timestamp_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_server_timestamp_request__free_unpacked
+                     (CMsgClientServerTimestampRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_server_timestamp_response__get_packed_size
+                     (const CMsgClientServerTimestampResponse   *message);
+size_t cmsg_client_server_timestamp_response__pack
+                     (const CMsgClientServerTimestampResponse   *message,
+                      uint8_t             *out);
+size_t cmsg_client_server_timestamp_response__pack_to_buffer
+                     (const CMsgClientServerTimestampResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientServerTimestampResponse *
+       cmsg_client_server_timestamp_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_server_timestamp_response__free_unpacked
+                     (CMsgClientServerTimestampResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_secret__get_packed_size
+                     (const CMsgClientSecret   *message);
+size_t cmsg_client_secret__pack
+                     (const CMsgClientSecret   *message,
+                      uint8_t             *out);
+size_t cmsg_client_secret__pack_to_buffer
+                     (const CMsgClientSecret   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientSecret *
+       cmsg_client_secret__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_secret__free_unpacked
+                     (CMsgClientSecret *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_hello__get_packed_size
+                     (const CMsgClientHello   *message);
+size_t cmsg_client_hello__pack
+                     (const CMsgClientHello   *message,
+                      uint8_t             *out);
+size_t cmsg_client_hello__pack_to_buffer
+                     (const CMsgClientHello   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientHello *
+       cmsg_client_hello__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_hello__free_unpacked
+                     (CMsgClientHello *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_logon__get_packed_size
+                     (const CMsgClientLogon   *message);
+size_t cmsg_client_logon__pack
+                     (const CMsgClientLogon   *message,
+                      uint8_t             *out);
+size_t cmsg_client_logon__pack_to_buffer
+                     (const CMsgClientLogon   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientLogon *
+       cmsg_client_logon__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_logon__free_unpacked
+                     (CMsgClientLogon *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_logon_response__get_packed_size
+                     (const CMsgClientLogonResponse   *message);
+size_t cmsg_client_logon_response__pack
+                     (const CMsgClientLogonResponse   *message,
+                      uint8_t             *out);
+size_t cmsg_client_logon_response__pack_to_buffer
+                     (const CMsgClientLogonResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientLogonResponse *
+       cmsg_client_logon_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_logon_response__free_unpacked
+                     (CMsgClientLogonResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_request_web_apiauthenticate_user_nonce__get_packed_size
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonce   *message);
+size_t cmsg_client_request_web_apiauthenticate_user_nonce__pack
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonce   *message,
+                      uint8_t             *out);
+size_t cmsg_client_request_web_apiauthenticate_user_nonce__pack_to_buffer
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonce   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientRequestWebAPIAuthenticateUserNonce *
+       cmsg_client_request_web_apiauthenticate_user_nonce__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_request_web_apiauthenticate_user_nonce__free_unpacked
+                     (CMsgClientRequestWebAPIAuthenticateUserNonce *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_request_web_apiauthenticate_user_nonce_response__get_packed_size
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonceResponse   *message);
+size_t cmsg_client_request_web_apiauthenticate_user_nonce_response__pack
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonceResponse   *message,
+                      uint8_t             *out);
+size_t cmsg_client_request_web_apiauthenticate_user_nonce_response__pack_to_buffer
+                     (const CMsgClientRequestWebAPIAuthenticateUserNonceResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientRequestWebAPIAuthenticateUserNonceResponse *
+       cmsg_client_request_web_apiauthenticate_user_nonce_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_request_web_apiauthenticate_user_nonce_response__free_unpacked
+                     (CMsgClientRequestWebAPIAuthenticateUserNonceResponse *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_log_off__get_packed_size
+                     (const CMsgClientLogOff   *message);
+size_t cmsg_client_log_off__pack
+                     (const CMsgClientLogOff   *message,
+                      uint8_t             *out);
+size_t cmsg_client_log_off__pack_to_buffer
+                     (const CMsgClientLogOff   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientLogOff *
+       cmsg_client_log_off__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_log_off__free_unpacked
+                     (CMsgClientLogOff *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_logged_off__get_packed_size
+                     (const CMsgClientLoggedOff   *message);
+size_t cmsg_client_logged_off__pack
+                     (const CMsgClientLoggedOff   *message,
+                      uint8_t             *out);
+size_t cmsg_client_logged_off__pack_to_buffer
+                     (const CMsgClientLoggedOff   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientLoggedOff *
+       cmsg_client_logged_off__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_logged_off__free_unpacked
+                     (CMsgClientLoggedOff *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_new_login_key__get_packed_size
+                     (const CMsgClientNewLoginKey   *message);
+size_t cmsg_client_new_login_key__pack
+                     (const CMsgClientNewLoginKey   *message,
+                      uint8_t             *out);
+size_t cmsg_client_new_login_key__pack_to_buffer
+                     (const CMsgClientNewLoginKey   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientNewLoginKey *
+       cmsg_client_new_login_key__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_new_login_key__free_unpacked
+                     (CMsgClientNewLoginKey *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_new_login_key_accepted__get_packed_size
+                     (const CMsgClientNewLoginKeyAccepted   *message);
+size_t cmsg_client_new_login_key_accepted__pack
+                     (const CMsgClientNewLoginKeyAccepted   *message,
+                      uint8_t             *out);
+size_t cmsg_client_new_login_key_accepted__pack_to_buffer
+                     (const CMsgClientNewLoginKeyAccepted   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientNewLoginKeyAccepted *
+       cmsg_client_new_login_key_accepted__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_new_login_key_accepted__free_unpacked
+                     (CMsgClientNewLoginKeyAccepted *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_account_info__get_packed_size
+                     (const CMsgClientAccountInfo   *message);
+size_t cmsg_client_account_info__pack
+                     (const CMsgClientAccountInfo   *message,
+                      uint8_t             *out);
+size_t cmsg_client_account_info__pack_to_buffer
+                     (const CMsgClientAccountInfo   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientAccountInfo *
+       cmsg_client_account_info__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_account_info__free_unpacked
+                     (CMsgClientAccountInfo *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_challenge_request__get_packed_size
+                     (const CMsgClientChallengeRequest   *message);
+size_t cmsg_client_challenge_request__pack
+                     (const CMsgClientChallengeRequest   *message,
+                      uint8_t             *out);
+size_t cmsg_client_challenge_request__pack_to_buffer
+                     (const CMsgClientChallengeRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientChallengeRequest *
+       cmsg_client_challenge_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_challenge_request__free_unpacked
+                     (CMsgClientChallengeRequest *message,
+                      ProtobufCAllocator *allocator);
+size_t cmsg_client_challenge_response__get_packed_size
+                     (const CMsgClientChallengeResponse   *message);
+size_t cmsg_client_challenge_response__pack
+                     (const CMsgClientChallengeResponse   *message,
+                      uint8_t             *out);
+size_t cmsg_client_challenge_response__pack_to_buffer
+                     (const CMsgClientChallengeResponse   *message,
+                      ProtobufCBuffer     *buffer);
+CMsgClientChallengeResponse *
+       cmsg_client_challenge_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   cmsg_client_challenge_response__free_unpacked
+                     (CMsgClientChallengeResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*CMsgClientHeartBeat_Closure)
+                 (const CMsgClientHeartBeat *message,
+                  void *closure_data);
+typedef void (*CMsgClientServerTimestampRequest_Closure)
+                 (const CMsgClientServerTimestampRequest *message,
+                  void *closure_data);
+typedef void (*CMsgClientServerTimestampResponse_Closure)
+                 (const CMsgClientServerTimestampResponse *message,
+                  void *closure_data);
+typedef void (*CMsgClientSecret_Closure)
+                 (const CMsgClientSecret *message,
+                  void *closure_data);
+typedef void (*CMsgClientHello_Closure)
+                 (const CMsgClientHello *message,
+                  void *closure_data);
+typedef void (*CMsgClientLogon_Closure)
+                 (const CMsgClientLogon *message,
+                  void *closure_data);
+typedef void (*CMsgClientLogonResponse_Closure)
+                 (const CMsgClientLogonResponse *message,
+                  void *closure_data);
+typedef void (*CMsgClientRequestWebAPIAuthenticateUserNonce_Closure)
+                 (const CMsgClientRequestWebAPIAuthenticateUserNonce *message,
+                  void *closure_data);
+typedef void (*CMsgClientRequestWebAPIAuthenticateUserNonceResponse_Closure)
+                 (const CMsgClientRequestWebAPIAuthenticateUserNonceResponse *message,
+                  void *closure_data);
+typedef void (*CMsgClientLogOff_Closure)
+                 (const CMsgClientLogOff *message,
+                  void *closure_data);
+typedef void (*CMsgClientLoggedOff_Closure)
+                 (const CMsgClientLoggedOff *message,
+                  void *closure_data);
+typedef void (*CMsgClientNewLoginKey_Closure)
+                 (const CMsgClientNewLoginKey *message,
+                  void *closure_data);
+typedef void (*CMsgClientNewLoginKeyAccepted_Closure)
+                 (const CMsgClientNewLoginKeyAccepted *message,
+                  void *closure_data);
+typedef void (*CMsgClientAccountInfo_Closure)
+                 (const CMsgClientAccountInfo *message,
+                  void *closure_data);
+typedef void (*CMsgClientChallengeRequest_Closure)
+                 (const CMsgClientChallengeRequest *message,
+                  void *closure_data);
+typedef void (*CMsgClientChallengeResponse_Closure)
+                 (const CMsgClientChallengeResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_steammessages_5fclientserver_5flogin_2eproto__INCLUDED */
diff --git a/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.proto b/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.proto
new file mode 100644
index 0000000000..f68ad765cf
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_clientserver_login.proto
@@ -0,0 +1,166 @@
+import "steammessages_base.proto";
+
+option optimize_for = SPEED;
+option cc_generic_services = false;
+
+message CMsgClientHeartBeat {
+	optional bool send_reply = 1;
+}
+
+message CMsgClientServerTimestampRequest {
+	optional uint64 client_request_timestamp = 1;
+}
+
+message CMsgClientServerTimestampResponse {
+	optional uint64 client_request_timestamp = 1;
+	optional uint64 server_timestamp_ms = 2;
+}
+
+message CMsgClientSecret {
+	optional uint32 version = 1;
+	optional uint32 appid = 2;
+	optional uint32 deviceid = 3;
+	optional fixed64 nonce = 4;
+	optional bytes hmac = 5;
+}
+
+message CMsgClientHello {
+	optional uint32 protocol_version = 1;
+}
+
+message CMsgClientLogon {
+	optional uint32 protocol_version = 1;
+	optional uint32 deprecated_obfustucated_private_ip = 2;
+	optional uint32 cell_id = 3;
+	optional uint32 last_session_id = 4;
+	optional uint32 client_package_version = 5;
+	optional string client_language = 6;
+	optional uint32 client_os_type = 7;
+	optional bool should_remember_password = 8 [default = false];
+	optional string wine_version = 9;
+	optional uint32 deprecated_10 = 10;
+	optional .CMsgIPAddress obfuscated_private_ip = 11;
+	optional uint32 deprecated_public_ip = 20;
+	optional uint32 qos_level = 21;
+	optional fixed64 client_supplied_steam_id = 22;
+	optional .CMsgIPAddress public_ip = 23;
+	optional bytes machine_id = 30;
+	optional uint32 launcher_type = 31 [default = 0];
+	optional uint32 ui_mode = 32 [default = 0];
+	optional uint32 chat_mode = 33 [default = 0];
+	optional bytes steam2_auth_ticket = 41;
+	optional string email_address = 42;
+	optional fixed32 rtime32_account_creation = 43;
+	optional string account_name = 50;
+	optional string password = 51;
+	optional string game_server_token = 52;
+	optional string login_key = 60;
+	optional bool was_converted_deprecated_msg = 70 [default = false];
+	optional string anon_user_target_account_name = 80;
+	optional fixed64 resolved_user_steam_id = 81;
+	optional int32 eresult_sentryfile = 82;
+	optional bytes sha_sentryfile = 83;
+	optional string auth_code = 84;
+	optional int32 otp_type = 85;
+	optional uint32 otp_value = 86;
+	optional string otp_identifier = 87;
+	optional bool steam2_ticket_request = 88;
+	optional bytes sony_psn_ticket = 90;
+	optional string sony_psn_service_id = 91;
+	optional bool create_new_psn_linked_account_if_needed = 92 [default = false];
+	optional string sony_psn_name = 93;
+	optional int32 game_server_app_id = 94;
+	optional bool steamguard_dont_remember_computer = 95;
+	optional string machine_name = 96;
+	optional string machine_name_userchosen = 97;
+	optional string country_override = 98;
+	optional bool is_steam_box = 99;
+	optional uint64 client_instance_id = 100;
+	optional string two_factor_code = 101;
+	optional bool supports_rate_limit_response = 102;
+	optional string web_logon_nonce = 103;
+	optional int32 priority_reason = 104;
+	optional .CMsgClientSecret embedded_client_secret = 105;
+	optional bool disable_partner_autogrants = 106;
+	optional bool is_steam_deck = 107;
+	optional string access_token = 108;
+	optional bool is_chrome_os = 109;
+	optional bool is_tesla = 110;
+}
+
+message CMsgClientLogonResponse {
+	optional int32 eresult = 1 [default = 2];
+	optional int32 legacy_out_of_game_heartbeat_seconds = 2;
+	optional int32 heartbeat_seconds = 3;
+	optional uint32 deprecated_public_ip = 4;
+	optional fixed32 rtime32_server_time = 5;
+	optional uint32 account_flags = 6;
+	optional uint32 cell_id = 7;
+	optional string email_domain = 8;
+	optional bytes steam2_ticket = 9;
+	optional int32 eresult_extended = 10;
+	optional string webapi_authenticate_user_nonce = 11;
+	optional uint32 cell_id_ping_threshold = 12;
+	optional bool deprecated_use_pics = 13;
+	optional string vanity_url = 14;
+	optional .CMsgIPAddress public_ip = 15;
+	optional fixed64 client_supplied_steamid = 20;
+	optional string ip_country_code = 21;
+	optional bytes parental_settings = 22;
+	optional bytes parental_setting_signature = 23;
+	optional int32 count_loginfailures_to_migrate = 24;
+	optional int32 count_disconnects_to_migrate = 25;
+	optional int32 ogs_data_report_time_window = 26;
+	optional uint64 client_instance_id = 27;
+	optional bool force_client_update_check = 28;
+	optional string agreement_session_url = 29;
+	optional uint64 token_id = 30;
+}
+
+message CMsgClientRequestWebAPIAuthenticateUserNonce {
+	optional int32 token_type = 1 [default = -1];
+}
+
+message CMsgClientRequestWebAPIAuthenticateUserNonceResponse {
+	optional int32 eresult = 1 [default = 2];
+	optional string webapi_authenticate_user_nonce = 11;
+	optional int32 token_type = 3 [default = -1];
+}
+
+message CMsgClientLogOff {
+}
+
+message CMsgClientLoggedOff {
+	optional int32 eresult = 1 [default = 2];
+}
+
+message CMsgClientNewLoginKey {
+	optional uint32 unique_id = 1;
+	optional string login_key = 2;
+}
+
+message CMsgClientNewLoginKeyAccepted {
+	optional uint32 unique_id = 1;
+}
+
+message CMsgClientAccountInfo {
+	optional string persona_name = 1;
+	optional string ip_country = 2;
+	optional int32 count_authed_computers = 5;
+	optional uint32 account_flags = 7;
+	optional uint64 facebook_id = 8;
+	optional string facebook_name = 9;
+	optional string steamguard_machine_name_user_chosen = 15;
+	optional bool is_phone_verified = 16;
+	optional uint32 two_factor_state = 17;
+	optional bool is_phone_identifying = 18;
+	optional bool is_phone_needing_reverify = 19;
+}
+
+message CMsgClientChallengeRequest {
+	optional fixed64 steamid = 1;
+}
+
+message CMsgClientChallengeResponse {
+	optional fixed64 challenge = 1;
+}
diff --git a/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.pb-c.cpp b/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.pb-c.cpp
new file mode 100644
index 0000000000..609dbc7db7
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.pb-c.cpp
@@ -0,0 +1,94 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_unified_base.steamclient.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "steammessages_unified_base.steamclient.pb-c.h"
+size_t no_response__get_packed_size
+                     (const NoResponse *message)
+{
+  assert(message->descriptor == &no_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t no_response__pack
+                     (const NoResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->descriptor == &no_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t no_response__pack_to_buffer
+                     (const NoResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->descriptor == &no_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+NoResponse *
+       no_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (NoResponse *)
+     protobuf_c_message_unpack (&no_response__descriptor,
+                                allocator, len, data);
+}
+void   no_response__free_unpacked
+                     (NoResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->descriptor == &no_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+
+#define no_response__field_descriptors NULL
+#define no_response__field_indices_by_name NULL
+#define no_response__number_ranges NULL
+const ProtobufCMessageDescriptor no_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "NoResponse",
+  "NoResponse",
+  "NoResponse",
+  "",
+  sizeof(NoResponse),
+  0,
+  no_response__field_descriptors,
+  no_response__field_indices_by_name,
+  0,  no_response__number_ranges,
+  NULL,NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCEnumValue eproto_execution_site__enum_values_by_number[2] =
+{
+  { "k_EProtoExecutionSiteUnknown", "EPROTO_EXECUTION_SITE__k_EProtoExecutionSiteUnknown", 0 },
+  { "k_EProtoExecutionSiteSteamClient", "EPROTO_EXECUTION_SITE__k_EProtoExecutionSiteSteamClient", 2 },
+};
+static const ProtobufCIntRange eproto_execution_site__value_ranges[] = {
+{0, 0},{2, 1},{0, 2}
+};
+static const ProtobufCEnumValueIndex eproto_execution_site__enum_values_by_name[2] =
+{
+  { "k_EProtoExecutionSiteSteamClient", 1 },
+  { "k_EProtoExecutionSiteUnknown", 0 },
+};
+const ProtobufCEnumDescriptor eproto_execution_site__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "EProtoExecutionSite",
+  "EProtoExecutionSite",
+  "EProtoExecutionSite",
+  "",
+  2,
+  eproto_execution_site__enum_values_by_number,
+  2,
+  eproto_execution_site__enum_values_by_name,
+  2,
+  eproto_execution_site__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
diff --git a/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.pb-c.h b/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.pb-c.h
new file mode 100644
index 0000000000..6347b969d1
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.pb-c.h
@@ -0,0 +1,71 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: steammessages_unified_base.steamclient.proto */
+
+#ifndef PROTOBUF_C_steammessages_5funified_5fbase_2esteamclient_2eproto__INCLUDED
+#define PROTOBUF_C_steammessages_5funified_5fbase_2esteamclient_2eproto__INCLUDED
+
+#include "protobuf-c.h"
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1000000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+struct NoResponse;
+
+
+/* --- enums --- */
+
+typedef enum _EProtoExecutionSite {
+  EPROTO_EXECUTION_SITE__k_EProtoExecutionSiteUnknown = 0,
+  EPROTO_EXECUTION_SITE__k_EProtoExecutionSiteSteamClient = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EPROTO_EXECUTION_SITE)
+} EProtoExecutionSite;
+
+/* --- descriptors --- */
+
+extern const ProtobufCEnumDescriptor    eproto_execution_site__descriptor;
+extern const ProtobufCMessageDescriptor no_response__descriptor;
+
+/* --- messages --- */
+
+struct NoResponse : public ProtobufCppMessage
+{
+  NoResponse() :
+     ProtobufCppMessage(no_response__descriptor)
+  {}
+
+};
+
+size_t no_response__get_packed_size
+                     (const NoResponse   *message);
+size_t no_response__pack
+                     (const NoResponse   *message,
+                      uint8_t             *out);
+size_t no_response__pack_to_buffer
+                     (const NoResponse   *message,
+                      ProtobufCBuffer     *buffer);
+NoResponse *
+       no_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   no_response__free_unpacked
+                     (NoResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*NoResponse_Closure)
+                 (const NoResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_steammessages_5funified_5fbase_2esteamclient_2eproto__INCLUDED */
diff --git a/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.proto b/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.proto
new file mode 100644
index 0000000000..b6feede149
--- /dev/null
+++ b/protocols/Steam/src/protobuf-c/steammessages_unified_base.steamclient.proto
@@ -0,0 +1,33 @@
+import "google/protobuf/descriptor.proto";
+
+option optimize_for = SPEED;
+option cc_generic_services = false;
+
+extend .google.protobuf.FieldOptions {
+	optional string description = 50000;
+}
+
+extend .google.protobuf.ServiceOptions {
+	optional string service_description = 50000;
+	optional .EProtoExecutionSite service_execution_site = 50008 [default = k_EProtoExecutionSiteUnknown];
+}
+
+extend .google.protobuf.MethodOptions {
+	optional string method_description = 50000;
+}
+
+extend .google.protobuf.EnumOptions {
+	optional string enum_description = 50000;
+}
+
+extend .google.protobuf.EnumValueOptions {
+	optional string enum_value_description = 50000;
+}
+
+enum EProtoExecutionSite {
+	k_EProtoExecutionSiteUnknown = 0;
+	k_EProtoExecutionSiteSteamClient = 2;
+}
+
+message NoResponse {
+}
diff --git a/protocols/Steam/src/stdafx.h b/protocols/Steam/src/stdafx.h
index c05a845a8d..4931099ca4 100644
--- a/protocols/Steam/src/stdafx.h
+++ b/protocols/Steam/src/stdafx.h
@@ -39,6 +39,11 @@
 #include "resource.h"

 #include "version.h"

 

+#include "protobuf-c/protobuf-c.h"

+

+#include "protobuf-c/steammessages_auth.steamclient.pb-c.h"

+#include "protobuf-c/steammessages_clientserver_login.pb-c.h"

+

 #define MODULE "Steam"

 #define DB_KEY_LASTMSGTS "LastMessageTS"

 

diff --git a/protocols/Steam/src/steam_login.cpp b/protocols/Steam/src/steam_login.cpp
index e23c33525e..e2937a203b 100644
--- a/protocols/Steam/src/steam_login.cpp
+++ b/protocols/Steam/src/steam_login.cpp
@@ -13,6 +13,10 @@ bool CSteamProto::IsMe(const char *steamId)
 
 void CSteamProto::Login()
 {
+	CMsgClientHello hello;
+	hello.protocol_version = STEAM_PROTOCOL_VERSION; hello.has_protocol_version = true;
+	WSSend(EMsg::ClientHello, hello);
+
 	ptrA token(getStringA("TokenSecret"));
 	ptrA sessionId(getStringA("SessionID"));
 	if (mir_strlen(token) > 0 && mir_strlen(sessionId) > 0) {
@@ -22,9 +26,12 @@ void CSteamProto::Login()
 
 	T2Utf username(getWStringA("Username"));
 	if (username == NULL)
-		SetStatus(ID_STATUS_OFFLINE);
-	else
-		SendRequest(new GetRsaKeyRequest(username), &CSteamProto::OnGotRsaKey);
+		LoginFailed();
+	else {
+		CAuthenticationGetPasswordRSAPublicKeyRequest request;
+		request.account_name = username.get();
+		WSSend(0, request);
+	}
 }
 
 void CSteamProto::LoginFailed()
diff --git a/protocols/Steam/src/steam_proto.h b/protocols/Steam/src/steam_proto.h
index d2992cfb8a..3bf5b5915c 100644
--- a/protocols/Steam/src/steam_proto.h
+++ b/protocols/Steam/src/steam_proto.h
@@ -3,13 +3,20 @@
 

 #define STEAM_SEARCH_BYID 1001

 #define STEAM_SEARCH_BYNAME 1002

-#define STEAM_TYPING_TIME 10

+

+#define STEAM_PROTOCOL_VERSION 65580

+#define STEAM_PROTOCOL_MASK 0x80000000

 

 // Global settings for all accounts: hosts' list

 #define STEAM_MODULE "Steam"

 #define DBKEY_HOSTS_COUNT "HostsCount"

 #define DBKEY_HOSTS_DATE  "HostsDate"

 

+enum EMsg

+{

+	ClientHello = 9805,

+};

+

 struct SendAuthParam

 {

 	MCONTACT hContact;

@@ -66,6 +73,8 @@ class CSteamProto : public PROTO<CSteamProto>
 	void __cdecl ServerThread(void *);

 	bool ServerThreadStub(const char *szHost);

 

+	void WSSend(int msgType, const ProtobufCppMessage &msg);

+

 	// requests

 	bool SendRequest(HttpRequest *request);

 	bool SendRequest(HttpRequest *request, HttpCallback callback, void *param = nullptr);

diff --git a/protocols/Steam/src/steam_server.cpp b/protocols/Steam/src/steam_server.cpp
index 24596894bf..f69592d4ea 100644
--- a/protocols/Steam/src/steam_server.cpp
+++ b/protocols/Steam/src/steam_server.cpp
@@ -58,6 +58,9 @@ bool CSteamProto::ServerThreadStub(const char *szHost)
 	m_hServerConn = pReply->nlc;
 	debugLogA("Websocket connection succeeded");
 
+	// Send init packets
+	Login();
+
 	bool bExit = false;
 	int offset = 0;
 	MBinBuffer netbuf;
@@ -67,7 +70,7 @@ bool CSteamProto::ServerThreadStub(const char *szHost)
 			break;
 
 		unsigned char buf[2048];
-		int bufSize = Netlib_Recv(m_hServerConn, (char *)buf + offset, _countof(buf) - offset, MSG_NODUMP);
+		int bufSize = Netlib_Recv(m_hServerConn, (char *)buf + offset, _countof(buf) - offset, 0);
 		if (bufSize == 0) {
 			debugLogA("Gateway connection gracefully closed");
 			bExit = !m_bTerminated;
@@ -92,7 +95,7 @@ bool CSteamProto::ServerThreadStub(const char *szHost)
 			size_t currPacketSize = bufSize - hdr.headerSize;
 			netbuf.append(buf, bufSize);
 			while (currPacketSize < hdr.payloadSize) {
-				int result = Netlib_Recv(m_hServerConn, (char *)buf, _countof(buf), MSG_NODUMP);
+				int result = Netlib_Recv(m_hServerConn, (char *)buf, _countof(buf), 0);
 				if (result == 0) {
 					debugLogA("Gateway connection gracefully closed");
 					bExit = !m_bTerminated;
diff --git a/protocols/Steam/src/steam_utils.cpp b/protocols/Steam/src/steam_utils.cpp
index 65d9f3dcc5..fbf2066b6e 100644
--- a/protocols/Steam/src/steam_utils.cpp
+++ b/protocols/Steam/src/steam_utils.cpp
@@ -1,5 +1,43 @@
 #include "stdafx.h"

 

+static bool sttIncludesSessionId(const ProtobufCppMessage &msg)

+{

+	if (!mir_strcmp(msg.descriptor->short_name, "CMsgClientHello"))

+		return false;

+	if (!mir_strcmp(msg.descriptor->short_name, "CMsgServiceMethodCallFromClientNonAuthed"))

+		return false;

+	return true;

+}

+

+void CSteamProto::WSSend(int msgType, const ProtobufCppMessage &msg)

+{

+	msgType |= STEAM_PROTOCOL_MASK;

+

+	CMsgProtoBufHeader hdr;

+	hdr.has_client_sessionid = hdr.has_steamid = hdr.has_jobid_source = hdr.has_jobid_target = true;

+	if (sttIncludesSessionId(msg)) {

+	}

+	else {

+		hdr.client_sessionid = 0;

+		hdr.steamid = 0;

+	}

+	hdr.jobid_source = hdr.jobid_target = -1;

+

+	unsigned hdrLen = (unsigned)protobuf_c_message_get_packed_size(&hdr);

+	MBinBuffer hdrbuf(hdrLen);

+	protobuf_c_message_pack(&hdr, (uint8_t *)hdrbuf.data());

+	hdrbuf.appendBefore(&hdrLen, sizeof(hdrLen));

+	hdrbuf.appendBefore(&msgType, sizeof(msgType));

+	Netlib_Dump(m_hServerConn, hdrbuf.data(), hdrbuf.length(), true, 0);

+

+	MBinBuffer body(protobuf_c_message_get_packed_size(&msg));

+	protobuf_c_message_pack(&msg, body.data());

+	Netlib_Dump(m_hServerConn, body.data(), body.length(), true, 0);

+

+	hdrbuf.append(body);

+	WebSocket_SendBinary(m_hServerConn, hdrbuf.data(), hdrbuf.length());

+}

+

 uint16_t CSteamProto::SteamToMirandaStatus(PersonaState state)

 {

 	switch (state) {